/*+----------+--------------------------------------------------+---------+
  | 11/02/97 |                                                  | Ver 1.0 |
  +----------+                   COMPTA.H                       +---------+
  |   RAO    |                                                  |  EIC |
  +----------+--------------------------------------------------+---------+
  |                                                                       |
  |    Ce fichier déclare les diverses types et fonctions de comptabilité |
  | pour les modules REV'A.O. interfacés.                                 |
  +-----------------------------------------------------------------------+*/
  #ifdef __BCPLUSPLUS__
    /* Utilisation par un assistant 32 bits, Compta32.dll ou Compta.bpl */
  #ifdef _COMPTA_BPL
    #define PACKAGE_COMPTA __declspec( dllexport)
  #else
    #define PACKAGE_COMPTA __declspec( dllimport)
  #endif
  # include <EICDos.h>
  # include <map>
    typedef dateDOS date;
  #else
     /* Utilisation par un assistant 16 bits */
  #  include <HyperLnk.h> /* Pour récup d'un compte à l'écran */
  #  include <EICFct.h>
  #  include <Dates.h>
  #endif

 #ifndef _COMPTA_H
  #define _COMPTA_H

// Codes des cycles
enum CODE_CYCLE {
  CYC_CAPITAUX = 0, // Capitaux permanents
  CYC_IMMO,         // Immobilisations
  CYC_STOCK,        // Stocks / Travaux en cours
  CYC_FOURN,        // Fournisseurs / Achats / Charges externes
  CYC_CLIENTS,      // Clients / Ventes
  CYC_PERSONNEL,    // Personnel / Organismes Sociaux
  CYC_ETAT,         // Etat
  CYC_GROUPE,       // Groupe et Associés
  CYC_TRESORERIE,   // Trésorerie
  CYC_AUTRES_CPTS,  // Autres Comptes
  CYC_EX_CRITIQUE,  // Examen Critique
  CYC_ETATS_FI,     // Etats financiers

  CYC_FIRST = CYC_CAPITAUX,
  CYC_LAST  = CYC_ETATS_FI,
  CYC_NUL   = 0xFF,
  CYC_NB_CYCLES = 13,       //A mettre à jour si on change le nombre de cycle
  CYC_NB_CYCLES_IMP = 10,
 };

  //#ifndef _AUTONOME



  /*** Types possible d'un journal ***/
  #define CPTA_JNAL_A_NOUVEAU  0
  #define CPTA_JNAL_ACHATS     1
  #define CPTA_JNAL_VENTES     2
  #define CPTA_JNAL_TRESO      3
  #define CPTA_JNAL_OD         4
  #define CPTA_JNAL_INVENTAIRE 5
  #define CPTA_JNAL_BALANCE    6
  #define CPTA_JNAL_LAST       CPTA_JNAL_BALANCE
  #define CPTA_JNAL_CADOR_LAST CPTA_JNAL_OD


  /**********************/
  /*** Plan Comptable ***/
  /**********************/
  #ifndef __BCPLUSPLUS__
   /*** Identifiant des compta auxilliaires (1er caractère du n° de compte) ***/
   /*** Les comptes généraux commencent toujours par un digit entre '1' et '8' ***/
   #define CPTA_CPT_CLIENT      'C'
   #define CPTA_CPT_FOURNISSEUR 'F'

  #endif
  #pragma pack(2)
  typedef struct tagCPTA_PC {
    char           szCompte[ 13 + 1];   /* N° de compte */
    char           szIntitule[ 35 + 1]; /* Intitulé du compte */
    double         dSoldeN;             /* Soldes */
    double         dSoldeNm1;
    double         dSoldeNm2;
    double         dSoldeNm3;
    double         dSoldeNm4;
    double         dDebitN;             /* Débits */
    double         dDebitNm1;
    double         dDebitNm2;
    double         dDebitNm3;
    double         dDebitNm4;
    double         dCreditN;            /* Crédits */
    double         dCreditNm1;
    double         dCreditNm2;
    double         dCreditNm3;
    double         dCreditNm4;
    unsigned short bIsInactif;          /* != 0 si compte inactif (non mouvementé depuis N-4) */
    unsigned short eCodeCycle;          /* Une valeur CYC_* */
   } CPTA_PC;
  #pragma pack()


  /******************/
  /*** Historique ***/
  /******************/
  /*** Structure de données d'un module RAO dans l'historique ***/
  #pragma pack(1)                  /*+---+---+----------------------------------+*/
  typedef union tagCPTA_HIRAODATA { /*|Pos|Len|           Description            |*/
      struct {                      /*|---+---+----------------------------------+*/
        char sTVTxTVA[ 4];          /*|000|  4| TV : Taux de TVA de l'écriture   |*/
        char sTVCodeTVA[ 2];        /*|004|  2| TV : Code TVA de l'écriture      |*/
        char sFiller[ 6];           /*|006|  6| ??                               |*/
      } TVA;
      struct {                      /*| Comptes 455                                     |*/
        char sDateValeur[ 6];       /*|000|  6| IC : Date de Valeur Intérêts CC         |*/
        char sCodeMvt[ 6];          /*|006|  6| IC : Code mouvement (Apport, prélèv...) |*/
      } ICC;                        /*+---+---+-----------------------------------------+*/
      struct {                      /*| Comptes 6                                       |*/
        char sDateDebPer[ 6];       /*|000|  6| CH : date de debut de periode           |*/
        char sDateFinPer[ 6];       /*|006|  6| CH : date de fin de periode             |*/
      } CH;                         /*+---+---+-----------------------------------------+*/
      struct {                      /*| Comptes 455                                     |*/
        char sFiller[ 6];           /*|000|  6| ??                                      |*/
        char sCodeMvt[ 6];          /*|006|  6| AN : Code mouvement (Apport, prélèv...) |*/
      } AN;                         /*+---+---+-----------------------------------------+*/
    } CPTA_HIRAODATA;               /*|Tot| 12|*/
  #pragma pack()                    /*+---+---+*/

  #pragma pack(2)
  typedef struct tagCPTA_HI {
    char           szCompte[ 13 + 1];     /* N° de compte de la ligne d'écriture */
    char           szCodeJournal[ 5 + 1]; /* Code du jnal ds lequel l'écriture a été passée */
	  char           szNoPiece[ 15 + 1];    /* N° de pièce            */
    char           szLibelle[ 35 + 1];    /* Libellé de l'opération */
	  char           szRAOPrefixeModule[ 2 + 1]; /* Préfixe du module émetteur de la ligne */
    char           cRAOIDEcriture;             /* ID - interne au module émetteur - de l'écriture */
   	char           szCodeJournalOrigine[ 5 + 1]; /* Code du jnal d'origine ds lequel l'écriture a été passée */
	  char           szLettrage[ 4 + 1];    /* Lettrage*/
	  char		       cRien;				          /* Caractere vide pour éviter les pb d'alignement du au prama pack(2) */
	  unsigned short _bRAODataModified;     /* Usage interne */
    long           _lOffset;              /*   "      "    */
    long           lIDForUpdate;          /* A transmettre à CptaHIUpdateRAOData()/CptaHIGetRAOData()/CptaHIUpdatePeriode( ) seulement */
    unsigned short eTypeJournal;          /* Type jnal ds lequel l'écriture a été passée CPTA_JNAL_* */    
    unsigned short bIsLettree;            /* != 0 si ligne d'écriture lettrée */
    date           dateImputation;        /* Date d'imputation de l'écriture */
    unsigned short bIsDebiteur;           /* != 0 si le montant de l'opération est débiteur */
    double         dMontant;              /* Montant de l'opération */    
    CPTA_HIRAODATA RAOModuleData;         /* Données privées de modules ([' '] si vide) */    
    unsigned long  IDEcriture;            /* ID de l'écriture */
    date           dateOrigine;           /* Date d'imputation d'origine de l'écriture */
    date           dateEcheance;          /* Date d'échéance de l'écriture */
    date           dateDebPeriode;        /* Date de début de période */
    date           dateFinPeriode;        /* Date de fin de période */
   } CPTA_HI;
  #pragma pack()
  /* Toutes les variables caractere ou chaines de caracteres doivent etre placees au debut de la structure et le nombre total de caracteres doit etre pair.
	 Si, sans compter la variable cRien, le nombre total de caracteres est pair mettre cette variable en commentaire pour garder l'alignement.
	 Sinon, laisser la variable cRien afin d'obtenir nombre total de caracteres pair. 
	 Actuellement, le nombre total de caracteres est = 14 + 6 + 16 + 36 + 3 + 1 + 6 + 5 = 87, donc ce nombre est impair et il faut laisser la variable cRien
	 pour obtenir un total de 88 caracteres et garder l'alignement. */

  /* Fonction d'énumération du HI */
  typedef void (FAR _cdecl* CPTA_HI_CALLBACK)(const CPTA_HI FAR* lpchi, long lUserData);

  //*******************************************//
   // Définition des identificateurs d'exercice //
   //*******************************************//
   #define IDEXERCICE_INCONNU 999
   #define IDEXERCICE_COURANT 100 // La signification de "exercice courant" est dynamique
   #define IDEXERCICE_Np1       1
   #define IDEXERCICE_N         0
   #define IDEXERCICE_Nm1      -1
   #define IDEXERCICE_Nm2      -2
   #define IDEXERCICE_Nm3      -3
   #define IDEXERCICE_Nm4      -4

   #define MAKERAOIDECRITURE(cModuleCodeFirst, cModuleCodeSecond, cModulePersonal)  (unsigned int)((((cModuleCodeFirst)&0xFF)<<16)|(((cModuleCodeSecond)&0xFF)<<24)|((cModulePersonal)&0xFF))

   /**************************************************/
   /*** Fonctions de gestion des numéros de compte ***/
   /**************************************************/
//#endif /* #ifndef _AUTONOME */
  #ifndef __BCPLUSPLUS__
    extern char* PASCAL CptaFormateCpte( char *szNoCpt, int nLen);
  #endif
//#ifndef _AUTONOME
  #ifndef __BCPLUSPLUS__
    /*** Récupération d'un n° de compte ***/
    extern void  PASCAL CptaBeginFreeNoCpt();
    extern void  PASCAL CptaEndFreeNoCpt();
    extern int   PASCAL CptaRecNoCpt( HSChamp hsNoCpt,
                                      char    szNoCpt[ 13 + 1]); /* retourne TRUE si n° cpt valide */
    extern int   PASCAL CptaIsCompteRacineDe( const char* pcszCompte, const char* pcszRacineEIC);

    extern char* PASCAL CptaGetCompteSelectionne( char szNoCpt[ 13 + 1]);
    extern int   PASCAL CptaPresente();
    extern short PASCAL PcContientAuMoinsUnCompte();


   /****************************************************/
   /*** Fonctions de gestion des fichiers comptables ***/
   /****************************************************/
   /*** Actions à l'ouverture d'un fichier ***/
   #define CPTA_ACT_ECRITURE       0x0002 /* Gestion du fichier des écritures (interne à la lib) */
   #define CPTA_ACT_HISTORIQUE     0x0004 /* Gestion du fichier historique */
   #define CPTA_ACT_PLAN_COMPTABLE 0x0008 /* Gestion du fichier plan-comptable */
   #define CPTA_ACT_RW             0x0010 /* Accès en Lecture/Ecriture (sinon Lecture seule) */
   #define CPTA_ACT_INVALIDATE     0x0020 /* Accès pour invalider/annuler (sinon valider) */

   #define CPTA_ACT_BARRE_MASK              0xF800 /* Usage interne : Masque des bits de gestion de la barre */
   #define CPTA_ACT_DEFAULT                 0x0000 /* Gestion par défaut de la barre */
   #define CPTA_ACT_NO_MSG_BARRE            0x0800 /* Pas de progression (ni d'initialisation) de la barre */
   #define CPTA_ACT_NO_PROGRESS_BARRE       0x1000 /* Pas de progression (ni d'initialisation) de la barre */
   #define CPTA_ACT_ONLY_BARRE_PLUS_ON_CALL 0x3000 /* Ne fait qu'incrémenter la barre de 1 après l'opération (inclut obligatoirement NO_PROGRESS) */
   #define CPTA_ACT_NO_OPEN_BARRE           0x4000 /* Ne pas ouvrir et fermer la barre */
   #define CPTA_ACT_NO_CLOSE_BARRE          0x8000 /* Laisser barre ouverte après CloseEcriture */
   #define CPTA_ACT_NO_BARRE                (CPTA_ACT_NO_OPEN_BARRE | CPTA_ACT_NO_MSG_BARRE | CPTA_ACT_NO_PROGRESS_BARRE | CPTA_ACT_NO_CLOSE_BARRE)

   /*** Fonctions d'ouverture/fermeture des fichiers ***/
   extern void PASCAL _CptaOpen(unsigned fAction); /* CPTA_ACT_* combinés */
   extern void PASCAL _CptaClose();

   /*** Fonctions de gestion des actions de la barre ***/
   extern unsigned PASCAL CptaPushNoBarreAction();
   extern void     PASCAL CptaPopNoBarreAction(unsigned uOldBarreAction);


   /********************************************/
   /*** Fonctions de gestion de l'historique ***/
   /********************************************/
   /*** Fonctionnalités ***/
   extern void PASCAL _CptaHIOpen(unsigned    fAction,        /* CPTA_* combinés */
                                   const date* pcDateDebImput, /* NULL = Date Deb Exercice */
                                   const date* pcDateFinImput);/* NULL = Date Situation */

   #define CptaHIOpenForRead(fActionBarre)     _CptaHIOpen(CPTA_ACT_HISTORIQUE               | (fActionBarre), NULL, NULL)
   #define CptaHIOpenForMAJ(fActionBarre)      _CptaHIOpen(CPTA_ACT_HISTORIQUE | CPTA_ACT_RW | (fActionBarre), NULL, NULL)
   #define CptaHIOpenMaintenance(fActionBarre) _CptaHIOpen(CPTA_ACT_HISTORIQUE | CPTA_ACT_RW | (fActionBarre), NULL, NULL)
   #define CptaHIClose()                        _CptaClose()

    extern void PASCAL CptaEnumHIComptesDansRacine(CPTA_HI_CALLBACK lpfnCptaHIEnum,
                                                    const char*      pcszRacine,
                                                    long             lUserData);
    extern void PASCAL CptaEnumHIDetailCompte(CPTA_HI_CALLBACK lpfnCptaHIEnum,
                                               const char*      pcszCompte,
                                               long             lUserData);

   extern int  PASCAL CptaHIGetFirstOfRacine(CPTA_HI* phi, const char cszRacine[ 13 + 1] /* "" = 1er cpt du HI */);
   extern int  PASCAL CptaHIGetNextOfRacine(CPTA_HI* phi);
   extern void PASCAL CptaHIUpdateRAOData(long lIDForUpdate, const CPTA_HIRAODATA* pcRAOModuleData);
   extern void PASCAL CptaHIGetRAOData(long lIDForUpdate, CPTA_HIRAODATA* pRAOModuleData);
   extern void PASCAL CptaHIUpdatePeriode(long lIDForUpdate, date *pDateDebPeriode, date *pDateFinPeriode);


   /**********************************************/
   /*** Fonctions de gestion du plan comptable ***/
   /**********************************************/
    /*** Types ***/
   /* Fonction d'énumération du PC */
    typedef void (FAR _cdecl* CPTA_PC_CALLBACK)(const CPTA_PC FAR* lpcpc, long lUserData);

   /*** Fonctionnalités ***/
   #define CptaPCOpenForRead(fActionBarre) _CptaOpen(CPTA_ACT_PLAN_COMPTABLE | (fActionBarre))
   #define CptaPCClose()                   _CptaClose()

    extern void PASCAL CptaEnumPCComptesDansRacine(CPTA_PC_CALLBACK lpfnCptaPCEnum,
                                                    const char*      pcszRacine, /* "" = Tous les comptes */
                                                    long             lUserData);

   extern int PASCAL CptaPCGetEQ(CPTA_PC* ppc, const char cszCompte[ 13 + 1]); /* != 0 si trouvé */

   extern int PASCAL CptaPCCreerCompteDlg( HWND       h,
                                           char       szCompteCree[ 13 + 1],
                                           char       szIntituleCree[ 35 + 1],
                                           const char cszRacineACreer[ 13 + 1] /* = NULL */); /* TRUE si créé */

   extern short PASCAL CptaPCCreerCompte( const CPTA_PC* ppc);


   /*****************************************************/
   /*** Fonctions de gestion des écritures comptables ***/
   /*****************************************************/
   /*** Types d'éritures comptables ***/
   #define CPTAECR_COURANTE                0x0001
   #define CPTAECR_INVENTAIRE              0x0002
   #define CPTAECR_A_CONTREPASSER          0x0004
   #define CPTAECR_A_NE_PAS_CONTREPASSER   0x0008

   #define CPTAECR_VALIDATE                0x0000 /* Pour valider une ecr. en compta */
   #define CPTAECR_CANCEL                  0x0010 /* Pour annuler une ecr. dans la compta */
   #define CPTAECR_NO_CONFIRM_CANCEL       0x0020 /* Ne confirme pas l'annulation de l'écr. en comtpa */

   /*** Gestion du fichier des écritures comptables ***/
   extern int PASCAL _CptaCloseAndSendEcriture(unsigned short fClose); /* TRUE si Ecriture envoyée */
   extern void PASCAL CptaCloseSansValiderEcriture(void);
   extern void PASCAL _CptaOpenEcriture( unsigned short fEcriture,           /* CPTAECR_*  */
                                         long           lNbPutToDo,          /* Nb de lignes à "puter" pour c't'écriture (>= 2) */
                                         char           cIDEcriture,         /* ID écriture perso au module */
                                         const date*    pcdateImputation);   /* NULL = date Situation */
   extern void PASCAL _CptaOpenEcritureAvecPiece( unsigned short fEcriture,           /* CPTAECR_*  */
												  long           lNbPutToDo,          /* Nb de lignes à "puter" pour c't'écriture (>= 2) */
										          long           lIDEcriture,         /* ID écriture perso au module */
										          const char*    pcszComplementPiece, /* Complément de pièce */
										          const date*    pcdateImputation);   /* NULL = date Situation */
   extern int PASCAL _CptaCancelEcriture( unsigned short fEcriture,           /* CPTAECR_*  */
                                          char           cIDEcriture,         /* ID écriture perso au module */
                                          const date*    pcdateImputation);   /* NULL = date Situation *//* TRUE si bien annulée */
   extern int PASCAL _CptaCancelEcritureAvecPiece( unsigned short fEcriture,           /* CPTAECR_*  */
                                                   long           lIDEcriture,         /* ID écriture perso au module */
										           const char*    pcszComplementPiece, /* Complément de pièce */
                                                   const date*    pcdateImputation);   /* NULL = date Situation *//* TRUE si bien annulée */

   extern void PASCAL CptaPutEcriture( const char*           pcszCompteImputation,
                                       const char*           pcszLibelleEcriture,
                                       unsigned short        bIsDebiteur,          /* != 0 si montant opération débiteur */
                                       double                dMontant,             /* != 0.0 */
                                       const CPTA_HIRAODATA* pcRAOData);           /* = NULL */

   extern short PASCAL CptaSupprimerEcritureJournalPieceDate(const char* pcszCodeJournal,     /* code journal des écritures à supprimer*/
                                                            const char* pcszPiece,           /* pièce des écritures à supprimer*/
                                                            const date*    pcdateImputation);/* date à partir de laquelle supprimer les écritures*/


   #define CptaOpenEcriture(fEcr,lNbPutToDo,cIDEcr)							_CptaOpenEcriture(fEcr,lNbPutToDo,cIDEcr,NULL)
   #define CptaOpenEcritureAvecPiece(fEcr,lNbPutToDo,lIDEcr,szCompPiece)	_CptaOpenEcritureAvecPiece(fEcr,lNbPutToDo,lIDEcr,szCompPiece,NULL)
   #define CptaCloseEcriture()												_CptaCloseAndSendEcriture(CPTAECR_VALIDATE)
   #define CptaCancelEcriture(fEcr,cIDEcr)									_CptaCancelEcriture(fEcr,cIDEcr,NULL)
   #define CptaCancelEcritureAvecPiece(fEcr,lIDEcr,szCompPiece)				_CptaCancelEcritureAvecPiece(fEcr,lIDEcr,szCompPiece,NULL)

   extern short PASCAL CptaGetJournalSelectionne(char *pCodeJournal);
   extern short PASCAL CptaJournalExiste(char *pCodeJournal);

   extern void  PASCAL CptaInitExportEcr(short bCptaOpen);
   extern int   PASCAL CptaAjoutEcrPourExport(void);
   extern int   PASCAL CptaEcrExportee(void);
   extern void  PASCAL CptaDesinitExportEcr(void);


 #else /* #ifndef _WIN32 */

  #include <Db.hpp>
  #include <DBTables.hpp>
  #include <DBGrids.hpp>

  #include <EIC.h>
  #include <CTable.h>
  #include <CDevise.h>
  #include <list.h>
  #include "uLetAuto.h"

  
  namespace Compta
  {
   #define COMPTE_D_ATTENTE "471ATTENTE"
   #define _loInsensitive (TLocateOptions() << loCaseInsensitive)
   #define _loNormal TLocateOptions()
   extern PACKAGE_COMPTA TDateTime      cm_DateFinExercice;       //Date de fin d'exercice pour incrémenter le solde N ou non suivant les dates d'écriture passées
   extern PACKAGE_COMPTA TDateTime      cm_DateSituation;  //Date servant pour le calcul des soldes
   extern PACKAGE_COMPTA bool cm_SoldeVisibleEgalSituation;
//   extern PACKAGE_COMPTA HWND hwndFenetreEICShell;
   extern PACKAGE_COMPTA bool cm_bEstMenufedEntreprise;


   const int IdEcritureNouvelle = 0;

   // Nature possible d'un journal
   enum JNNature {
     JNNATURE_OD          = 0,
     JNNATURE_A_NOUVEAUX,
     JNNATURE_ACHATS,  //Ex JNNATRUE_ACHATS
     JNNATURE_VENTES,
     JNNATURE_TRESORERIE,
     JNNATURE_INVENTAIRE,
     JNNATURE_BALANCE,
//     JNNATURE_ENCAISSEMENT,  // Ajouter pour les retraits et les remises en banque
//     JNNATURE_DECAISSEMENT,  //                         "
//     JNNATURE_REMISEBANQUE,  //                         "
//     JNNATURE_RETRAITBANQUE, //                         "

     JNNATURE_DEFAULT = JNNATURE_OD
   };

   // Liste des modes de paiement possible
   enum MODE_PAIEMENT { MP_AUCUN              = -1,
                        MP_ESPECES            =  0,
                        MP_CHEQUE             =  1,
                        MP_CARTEBANCAIRE      =  2,
                        MP_VIREMENT           =  3,
                        MP_PRELEVEMENT        =  5,
                        MP_EFFETCOM_RECEPTION =  6,
                        MP_EFFETCOM_ESCOMPTE  =  7,
                        MP_EFFETCOM_ENCAIS    =  8,
                        MP_TITRERESTO         = 10,
                        MP_CHEQUEVANCANCES    = 11,
                        MP_TIP                = 12,
                        MP_COMPENSATION       = 13,
                        MP_BILLET_ORDRE_REL   = 14,
                        MP_LETTRE_CHANGE_REL  = 15,
                        MP_VIREMENT_TRESO     = 16,
                        MP_TELEREGL_INTERNET  = 17,
                        MP_BILLET_ORDRE       = 18,
                        MP_LETTRE_CHANGE      = 19 };
   #define MAX_MODE_PAIEMT 18
   enum TYPE_LISTE    { TL_ACHATS=1, TL_REMISEBANQUE=2, TL_ENCAISSEMENT=4, TL_DECAISSEMENT=8, TL_TOUS=16, TL_VENTES=32 };

   #pragma pack( 2)
   typedef struct {
     enum MODE_PAIEMENT eModePaiemt;
     int                nTypeListe;
     char              *szAbreviation;
     char              *szDesignation;
   } DEF_MODE_PAIEMENT;
   #pragma pack()

   extern PACKAGE_COMPTA void               __fastcall ComptaGetListeModePaiement          ( enum TYPE_LISTE eTypeListe, TStrings *pLstAbrevation, TStrings *pLstDesignation);
   extern PACKAGE_COMPTA AnsiString         __fastcall ComptaGetDesignationPaiement        ( const AnsiString &strAbreviation);
   extern PACKAGE_COMPTA enum MODE_PAIEMENT __fastcall ComptaGetModePaiement               ( const AnsiString &strModePaiemt);
   extern PACKAGE_COMPTA enum MODE_PAIEMENT __fastcall ComptaGetModePaiementWithDesignation( const AnsiString &strDesignation);
   extern PACKAGE_COMPTA AnsiString         __fastcall ComptaGetModePaiementString         ( enum MODE_PAIEMENT eModeP);
   extern PACKAGE_COMPTA AnsiString         __fastcall ComptaGetModePaiementAbreviation    ( enum MODE_PAIEMENT eModeP);

   extern PACKAGE_COMPTA void               __fastcall ComptaSetAutoID( int nAutoID);
   extern PACKAGE_COMPTA int                __fastcall ComptaGetNewAutoID();
   extern PACKAGE_COMPTA bool               __fastcall ComptaEstUnCompteAcceptantAnalytique( const AnsiString &strCompte);
   extern PACKAGE_COMPTA bool               __fastcall ComptaEstUnCompteAnalytique(const AnsiString &strCompte);

   extern PACKAGE_COMPTA bool               __fastcall ComptaEstValide();

  enum ePeriodeCloture
  {
    epc_Inconnue = 0,
    epc_EnFonctionCabinetEntreprise,
    epc_Provisoire,
    epc_Definitive,
  };
  extern PACKAGE_COMPTA bool __fastcall ComptaPeriodeContientPeriodeCloturee( const TDateTime &dtDeb, const TDateTime &dtFin,enum ePeriodeCloture Option = epc_EnFonctionCabinetEntreprise);
  extern PACKAGE_COMPTA bool __fastcall ComptaEstDateSurPeriodeCloturee( const TDateTime &dtEcr,enum ePeriodeCloture Option = epc_EnFonctionCabinetEntreprise);

   //**********//
   // CJournal //
   //**********////////////////////////////////////////////////////////////////////
   //                                                                            //
   //    Cette classe permet de stocker les attributs d'un journal.              //
   ////////////////////////////////////////////////////////////////////////////////
   class PACKAGE_COMPTA CJournal
   {
    private:
     AnsiString    m_strCode;     //   Code   du journal (tjs en majuscules)
     AnsiString    m_strIntitule; // Intitulé "     "
     enum JNNature m_eNature;     //  Nature  "     "
    public:
     __property AnsiString    Code     = { read = m_strCode,     write = m_strCode};
     __property AnsiString    Intitule = { read = m_strIntitule, write = m_strIntitule};
     __property enum JNNature Nature   = { read = m_eNature,     write = m_eNature};
     void      __fastcall RAZ();
     CJournal& __fastcall operator = (const CJournal& jnlSrc);
     __fastcall CJournal() { RAZ(); }
     __fastcall CJournal(const AnsiString& strCode,
                          const AnsiString& strIntitule,
                          enum JNNature     eNature) : m_strCode(strCode), m_strIntitule(strIntitule), m_eNature(eNature) {}
   }; /* class CJournal */


   //***********//
   // TTableJnx //
   //***********///////////////////////////////////////////////////////////////////
   //                                                                            //
   //    Cette classe encapsule les traitements relatifs aux journaux comptables.//
   //                                                                            //
   // Clé primaire : CodeJournal                                                 //
   ////////////////////////////////////////////////////////////////////////////////
   class PACKAGE_COMPTA TTableJnx : public CTable
   {
    public:
     #define szfJN_Code                 "Code"
     #define szfJN_Intitule             "Intitule"
     #define szfJN_Nature               "Nature"    // Cf "enum JNNature"
     #define szfJN_Flags                "Flags"     // cf "enum JNFlags"
     #define szfJN_ModalitesSaisie      "ModalitesSaisie"
     #define szfJN_CompteContrepartie   "CompteContrepartie"
     #define szfJN_EncaisModSaisie      "EncaisModSaisie"
     #define szfJN_EncaisCptTreso       "EncaisCptTreso"
     #define szfJN_DeviseDefClassique   "DeviseDefClassique"
     #define szfJN_DeviseDefEncais      "DeviseDefEncais"
     #define szfJN_CodeOrigine          "CodeO"
     #define szfJN_AchVntModalSais      "AchVntModalSais"
     #define szfJN_AchVntLibelle        "AchVntLibelle"
     #define szfJN_AchVntDeviseDefaut   "AchVntDeviseDefaut"
     #define szfJN_AchVntModePaiement   "AchVntModePaiement"
     #define szfJN_AchVntCptTVA_biens   "AchVntCptTVA_biens"
     #define szfJN_AchVntCptTVA_immo    "AchVntCptTVA_immo"
     #define szfJN_AchVntCptTVA_col     "AchVntCptTVA_col"
     #define szfJN_AchVntBanquePaiement "AchVntBanquePaiement"
     #define szfJN_AchVntDateEchJour    "AchVntDateEchJour"
     #define szfJN_AchVntDateEchMode    "AchVntDateEchMode"
     #define szfJN_AchVntDateEchLe      "AchVntDateEchLe"
     #define szfJN_KmModalSais          "KmModalSais"
     #define szfJN_KmDeviseDefaut       "KmDeviseDefaut"
     #define szfJN_KmDeviseCompte       "KmDeviseCompte"
     #define szfJN_KmTauxFixe           "KmTauxFixe"
     #define szfJN_AchVntDematModalSais "AchVntDematModalSais"

     static const AnsiString strfJN_Code;
     static const AnsiString strfJN_Intitule;
     static const AnsiString strfJN_Nature;
     static const AnsiString strfJN_Flags;
     static const AnsiString strfJN_ModalitesSaisie;
     static const AnsiString strfJN_CompteContrepartie;
     static const AnsiString strfJN_EncaisModSaisie;
     static const AnsiString strfJN_EncaisCptTreso;
     static const AnsiString strfJN_DeviseDefClassique;
     static const AnsiString strfJN_DeviseDefEncais;
     static const AnsiString strfJN_CodeOrigine;
     static const AnsiString strfJN_AchVntModalSais;
     static const AnsiString strfJN_AchVntLibelle;
     static const AnsiString strfJN_AchVntDeviseDefaut;
     static const AnsiString strfJN_AchVntModePaiement;
     static const AnsiString strfJN_AchVntCptTVA_biens;
     static const AnsiString strfJN_AchVntCptTVA_immo;
     static const AnsiString strfJN_AchVntCptTVA_col;
     static const AnsiString strfJN_AchVntBanquePaiement;
     static const AnsiString strfJN_AchVntDateEchJour;
     static const AnsiString strfJN_AchVntDateEchMode;
     static const AnsiString strfJN_AchVntDateEchLe;
     static const AnsiString strfJN_KmModalSais;
     static const AnsiString strfJN_KmDeviseDefaut;
     static const AnsiString strfJN_KmDeviseCompte;
     static const AnsiString strfJN_KmTauxFixe;
     static const AnsiString strfJN_AchVntDematModalSais;

    public:
     enum JNFlags { // Valeurs possibles du champ "Flags"
       JNFLAGS_AUCUN    = 0x00000000, // Valeur par défaut du champ
       JNFLAGS_EIC      = 0x00000001, // Ce journal a été créé par EIC
       JNFLAGS_READONLY = 0x00000002  // Ce journal n'est pas modifiable et est en lecture seule (du point de vue le l'utilisateur)
     };

     enum JNModalSais { // Drapeaux possibles du champ binaire "Modalités de Saisie"
       JNModalSais_SAISIE_PIECE         = 0x00000001,
       JNModalSais_SAISIE_LIBELLE       = 0x00000002,
       JNModalSais_VALIDATION_AUTO      = 0x00000004,
       JNModalSais_RETOUR_SUR_MOIS      = 0x00000008,
       JNModalSais_RETOUR_SUR_JOUR      = 0x00000010,
       JNModalSais_RETOUR_SUR_PIECE     = 0x00000020,
       JNModalSais_CTREPARTIE_AUTO      = 0x00000040,
       JNModalSais_CTREPARTIE_SEMI_AUTO = 0x00000080,
       JNModalSais_PIECE_UNIQUE         = 0x00000100,
       JNModalSais_DEVISE_COMPTA        = 0x00000200,
       JNModalSais_DERNIERE_DEVISE      = 0x00000400,
       JNModalSais_UNGO_DEVISE          = 0x00000800,

       JNModalSais_DEFAULT = JNModalSais_SAISIE_PIECE | JNModalSais_SAISIE_LIBELLE | JNModalSais_PIECE_UNIQUE | JNModalSais_DEVISE_COMPTA
     };

     enum JNAchVntModalSaisieGeneral {
       JNAchVntModalSaisGen_PIECE_EXTERNE             = 0x00000001,
       JNAchVntModalSaisGen_PIECE_INTERNE             = 0x00000002,
       JNAchVntModalSaisGen_PIECE_INTERNE_MANUELLE    = 0x00000004,
       JNAchVntModalSaisGen_PIECE_INTERNE_AUTOMATIQUE = 0x00000008,
       JNAchVntModalSaisGen_MONTANT_TTC               = 0x00000010,

       JNAchVntModalSaisGen_RETOUR_AUTOMATIQUE        = 0x00000020,
       JNAchVntModalSaisGen_RETOUR_PIECE              = 0x00000040,
       JNAchVntModalSaisGen_RETOUR_MOIS               = 0x00000080,
       JNAchVntModalSaisGen_RETOUR_JOUR               = 0x00000100,

       JNAchVntModalSaisGen_COMPTE                    = 0x00000200,
       JNAchVntModalSaisGen_MONTANT_TENUE             = 0x00000400,
       JNAchVntModalSaisGen_LIBELLE                   = 0x00000800,
       JNAchVntModalSaisGen_QUANTITE                  = 0x00001000,

       JNAchVntModalSaisGen_ECH_DATE                  = 0x00002000,
       JNAchVntModalSaisGen_ECH_MODE_PAIEMENT         = 0x00004000,
       JNAchVntModalSaisGen_ECH_BANQUE_PAIEMENT       = 0x00008000,

       JNAchVntModalSaisGen_PASS_DEVISE               = 0x00010000,
       JNAchVntModalSaisGen_PASS_DEVISE_TENUE_COMPTA  = 0x00020000,
       JNAchVntModalSaisGen_PASS_DERNIERE_DEVISE      = 0x00040000,
       JNAchVntModalSaisGen_PASS_DEVISE_FOURNISSEUR   = 0x00080000,
       JNAchVntModalSaisGen_UNPASS_DEVISE_SPEC        = 0x00100000,
       JNAchVntModalSaisGen_UNPASS_DEVISE_FOURNISSEUR = 0x00200000,

       JNAchVntModalSaisGen_TVA_CALCUL_AUTOMATIQUE    = 0x00400000,

       JNAchVntModalSaisGen_ANALYTIK                  = 0x00800000,
       JNAchVntModalSaisGen_MONTANT_HT                = 0x01000000,
       JNAchVntModalSaisGen_RETOUR_TIERS              = 0x02000000,

       JNAchVntModalSaisGen_AVOIR_ECRITURE_NEGATIVE   = 0x04000000,

       //JNAchVntModalSaisGen_PIECE_INIT_MOIS           = 0x00800000,
       //JNAchVntModalSaisGen_PIECE_INIT_EXERCICE       = 0x01000000,
       //JNAchVntModalSaisGen_PIECE_INIT_MANUELLE       = 0x02000000,
       //JNAchVntModalSaisGen_PIECE_FORMAT_N            = 0x04000000,
       //JNAchVntModalSaisGen_PIECE_FORMAT_AN           = 0x08000000,
       //JNAchVntModalSaisGen_PIECE_FORMAT_AMN          = 0x10000000,

       JNAchVntModalSaisGen_DEFAULT = JNAchVntModalSaisGen_PIECE_INTERNE          |
                                      JNAchVntModalSaisGen_PIECE_INTERNE_MANUELLE | JNAchVntModalSaisGen_RETOUR_MOIS   |
                                      JNAchVntModalSaisGen_COMPTE                 | JNAchVntModalSaisGen_MONTANT_TENUE |
                                      JNAchVntModalSaisGen_LIBELLE                | JNAchVntModalSaisGen_QUANTITE      |
                                      JNAchVntModalSaisGen_UNPASS_DEVISE_SPEC     | JNAchVntModalSaisGen_TVA_CALCUL_AUTOMATIQUE
     };

     enum JNAchVntModalSaisieLibelle {
       JNAchVntModalSaisLbl_TVA_BS_NEANT              = 0x00000001,
       JNAchVntModalSaisLbl_TVA_IMMOBIL_NEANT         = 0x00000002,
       JNAchVntModalSaisLbl_TVA_COLLECTEE_NEANT       = 0x00000004,
       JNAchVntModalSaisLbl_TTC_NEANT                 = 0x00000008,
       JNAchVntModalSaisLbl_AUTRES_NEANT              = 0x00000010,

       JNAchVntModalSaisLbl_TVA_BS_DESIGNATION        = 0x00000020,
       JNAchVntModalSaisLbl_TVA_IMMOBIL_DESIGNATION   = 0x00000040,
       JNAchVntModalSaisLbl_TVA_COLLECTEE_DESIGNATION = 0x00000080,
       JNAchVntModalSaisLbl_TTC_DESIGNATION           = 0x00000100,
       JNAchVntModalSaisLbl_AUTRES_DESIGNATION        = 0x00000200,

       JNAchVntModalSaisLbl_TVA_BS_INTITULE           = 0x00000400,
       JNAchVntModalSaisLbl_TVA_IMMOBIL_INTITULE      = 0x00000800,
       JNAchVntModalSaisLbl_TVA_COLLECTEE_INTITULE    = 0x00001000,
       JNAchVntModalSaisLbl_TTC_INTITULE              = 0x00002000,
       JNAchVntModalSaisLbl_AUTRES_INTITULE           = 0x00004000,
                                                         
       JNAchVntModalSaisLbl_TVA_BS_INTITULE_COMPTE          = 0x00008000,
       JNAchVntModalSaisLbl_TVA_IMMOBIL_INTITULE_COMPTE     = 0x00010000,
       JNAchVntModalSaisLbl_TVA_COLLECTEE_INTITULE_COMPTE   = 0x00020000,
       JNAchVntModalSaisLbl_TTC_INTITULE_COMPTE             = 0x00040000,
       JNAchVntModalSaisLbl_AUTRES_INTITULE_COMPTE          = 0x00080000,

       JNAchVntModalSaisLbl_TVA_BS_1ERE_LIGNE_DETAIL        = 0x00100000,
       JNAchVntModalSaisLbl_TVA_IMMOBIL_1ERE_LIGNE_DETAIL   = 0x00200000,
       JNAchVntModalSaisLbl_TVA_COLLECTEE_1ERE_LIGNE_DETAIL = 0x00400000,
       JNAchVntModalSaisLbl_TTC_1ERE_LIGNE_DETAIL           = 0x00800000,
       JNAchVntModalSaisLbl_AUTRES_1ERE_LIGNE_DETAIL        = 0x01000000,

       JNAchVntModalSaisLbl_DEFAULT = JNAchVntModalSaisLbl_TVA_BS_NEANT        | JNAchVntModalSaisLbl_TVA_IMMOBIL_NEANT |
                                      JNAchVntModalSaisLbl_TVA_COLLECTEE_NEANT | JNAchVntModalSaisLbl_TTC_NEANT         |
                                      JNAchVntModalSaisLbl_AUTRES_NEANT
     };

     enum JNKmModalSaisie {
       JNKmModalSais_PIECE_INTERNE_MANUELLE = 0x00000001,
       JNKmModalSais_PIECE_INTERNE_AUTO     = 0x00000002,
       JNKmModalSais_LIBELLE_DEF_COMPTE     = 0x00000004,
       JNKmModalSais_LIBELLE_DEF_PRECEDENT  = 0x00000008,
       JNKmModalSais_LIBELLE_DEF_NEANT      = 0x00000010,
       JNKmModalSais_DEVISE_DEF_TENUE       = 0x00000020,
       JNKmModalSais_DEVISE_DEF_DERNIERE    = 0x00000040,
       JNKmModalSais_DEVISE_DEF_SPEC        = 0x00000080,
       JNKmModalSais_DEVISE_DEF_NEANT       = 0x00000100,
       JNKmModalSais_TAUX_SAISI             = 0x00000200,
       JNKmModalSais_TAUX_FIXE              = 0x00000400,
       JNKmModalSais_LIBELLE_A_ECRASER      = 0x00000800, // sinon à compléter

       JNKmModalSais_DEFAULT                = JNKmModalSais_PIECE_INTERNE_MANUELLE | JNKmModalSais_LIBELLE_DEF_NEANT |
                                              JNKmModalSais_DEVISE_DEF_TENUE       | JNKmModalSais_TAUX_SAISI
     };

     enum JNEncModalSais { // Drapeaux possibles du champ binaire "Modalités de Saisie des encaissements"
       JNEncModalSais_PIECE                  = 0x00000001,
       JNEncModalSais_FACTURE                = 0x00000002,
       JNEncModalSais_RETOUR_AUTOMATIQUE     = 0x00000004,
       JNEncModalSais_RETOUR_PIECE           = 0x00000008,
       JNEncModalSais_RETOUR_MOIS            = 0x00000010,
       JNEncModalSais_RETOUR_JOUR            = 0x00000020,
       JNEncModalSais_NATURE_PIECE           = 0x00000040,
       JNEncModalSais_AFFICHAGE_CLIENTS_AUTO = 0x00000080,
       JNEncModalSais_DEVISE_COMPTA          = 0x00000100,
       JNEncModalSais_DERNIERE_DEVISE        = 0x00000200,
       JNEncModalSais_UNGO_DEVISE            = 0x00000400,
       // Modalités de saisie des décaissements
       JNDecModalSais_PIECE                  = 0x00010000,
       JNDecModalSais_FACTURE                = 0x00020000,
       JNDecModalSais_RETOUR_AUTOMATIQUE     = 0x00040000,
       JNDecModalSais_RETOUR_PIECE           = 0x00080000,
       JNDecModalSais_RETOUR_MOIS            = 0x00100000,
       JNDecModalSais_RETOUR_JOUR            = 0x00200000,
       JNDecModalSais_NATURE_PIECE           = 0x00400000,
       JNDecModalSais_AFFICHAGE_FOURNIS_AUTO = 0x00800000,
       JNDecModalSais_DEVISE_COMPTA          = 0x01000000,
       JNDecModalSais_DERNIERE_DEVISE        = 0x02000000,
       JNDecModalSais_UNGO_DEVISE            = 0x04000000,

       JNEncModalSais_DEFAULT = JNEncModalSais_PIECE         | JNEncModalSais_FACTURE     |
                                JNEncModalSais_NATURE_PIECE  | JNEncModalSais_RETOUR_MOIS |
                                JNEncModalSais_DEVISE_COMPTA |
                                JNDecModalSais_PIECE         | JNDecModalSais_FACTURE     |
                                JNDecModalSais_NATURE_PIECE  | JNDecModalSais_RETOUR_MOIS |
                                JNDecModalSais_DEVISE_COMPTA
     };

    // Propriétés redéfinies
    __published:
     __property EICCodeTable = { stored = false}; // Initialisé via constructeur

    // Nouvelles propriétés
    private:
     typedef CTable inherited;
     bool __fastcall GetAFlagIsOn(int fFlags);
     bool __fastcall GetReadOnly();
     AnsiString __fastcall GetJournalAN();

    public:
     static bool VoirJournauxInventaires;
     static bool CocheOCRpourJournauxAchat;
     static bool CocheOCRpourJournauxVente;

     __property bool EstEIC      = { read = GetAFlagIsOn, index = JNFLAGS_EIC};
     __property bool EstReadOnly = {read = GetReadOnly};
     __property AnsiString AN = {read = GetJournalAN};

    // Les opérations suivantes modifient l'enregistrement courant de la table
     __fastcall TTableJnx(TComponent* pOwner);
     virtual __fastcall ~TTableJnx() {};
     void          __fastcall Get(const AnsiString& strCodeJnl, CJournal& jnl);
     bool          __fastcall Exist(const AnsiString& strCodeJnl);
     enum JNNature __fastcall Nature(const AnsiString& strCodeJnl);
     bool          __fastcall Creer(const CJournal& jnl);
     bool          __fastcall CreerDlg(EICTag            tag,
                                        const AnsiString& strNewCodeJnl,
                                        bool&             bExisteDeja,
                                        void*             hInstance = HInstance);
     AnsiString __fastcall Selectionner(bool VoirEIC = true,bool VoirReadOnly = false);
     void          __fastcall Modifier(const CJournal& jnl);
     void          __fastcall GetNaturesJnl( TStrings *pNatures);
     AnsiString    __fastcall GetTextNature( JNNature eNature);

    // Les opérations suivantes ne modifient pas l'enregistrement courant de la table
     bool __fastcall ModifierCourantDlg(EICTag tag); // TRUE s'il y a eu modification
   }; /* class TTableJnx */


   //*********//
   // CCompte //
   //*********/////////////////////////////////////////////////////////////////////
   //                                                                            //
   //    Cette classe permet de stocker les attributs d'un compte du PC.         //
   ////////////////////////////////////////////////////////////////////////////////
   class PACKAGE_COMPTA CCompte
   {
    private:
     AnsiString m_strCompte,m_CompteO;       // N° du compte
     AnsiString m_strIntitule;     // Intitulé usuel du compte
     AnsiString m_strIntituleLong; //     "    long  "    "
     TCodeDev   m_eCodeDevise;     // Code de la devise par défaut du compte
     Currency   m_curDebit;        // Débit  Exercice N
     Currency   m_curCredit;       // Crédit    "     "
     bool       m_bMouvementeNm1;  // TRUE si le compte a été mouvementé sur N-1
     Currency   m_curSoldeNm1;     // Solde N-1 (à zéro en lecture si m_bMouvementeNm1 est false, ignoré en écriture si m_bMouvementeNm1 est false)
     bool       m_bMouvementeNm2;  // TRUE si le compte a été mouvementé sur N-2
     Currency   m_curSoldeNm2;     // Solde N-2 (à zéro en lecture si m_bMouvementeNm2 est false, ignoré en écriture si m_bMouvementeNm2 est false)
     bool       m_bMouvementeNm3;  // TRUE si le compte a été mouvementé sur N-3
     Currency   m_curSoldeNm3;     // Solde N-3 (à zéro en lecture si m_bMouvementeNm3 est false, ignoré en écriture si m_bMouvementeNm3 est false)
     bool       m_bMouvementeNm4;  // TRUE si le compte a été mouvementé sur N-4
     Currency   m_curSoldeNm4;     // Solde N-4 (à zéro en lecture si m_bMouvementeNm4 est false, ignoré en écriture si m_bMouvementeNm4 est false)
     bool       m_bRANDetaille;    // TRUE si le Report A Nouveau du compte doit être détaillé
     bool       m_bSaisiePeriodes; // TRUE si le compte est un compte concerné par la saisie des périodes
     bool       m_bSupprime;       //  "   "  "  compte est supprimé
     AnsiString m_strCompteAbrege; // N° du compte abrégé
    private:
     // Les Get
     inline const AnsiString& __fastcall GetCompte()       const { return(m_strCompte);}
     inline const AnsiString& __fastcall GetIntitule()     const { return(m_strIntitule);}
     inline const AnsiString& __fastcall GetIntituleLong() const { return(m_strIntituleLong);}
     inline const Currency&   __fastcall GetDebit()        const { return(m_curDebit);}
     inline const Currency&   __fastcall GetCredit()       const { return(m_curCredit);}
     inline const Currency    __fastcall GetSolde()        const { return(m_curDebit - m_curCredit);}
     inline const AnsiString& __fastcall GetCompteAbrege() const { return(m_strCompteAbrege);}

     // Les Set
     inline void __fastcall SetCompte(const AnsiString& strCompte)             { m_strCompte       = strCompte;}
     inline void __fastcall SetIntitule(const AnsiString& strIntitule)         { m_strIntitule     = strIntitule;}
     inline void __fastcall SetIntituleLong(const AnsiString& strIntituleLong) { m_strIntituleLong = strIntituleLong;}
     inline void __fastcall SetCompteAbrege(const AnsiString& strCompteAbrege) { m_strCompteAbrege = strCompteAbrege;}

    public:
     __property const AnsiString Compte           = { read = GetCompte,        write = SetCompte};
     __property const AnsiString CompteOrigine    = { read = m_CompteO,        write = m_CompteO};
     __property const AnsiString Intitule         = { read = GetIntitule,      write = SetIntitule};
     __property const AnsiString IntituleLong     = { read = GetIntituleLong,  write = SetIntituleLong};
     __property TCodeDev         CodeDevise       = { read = m_eCodeDevise,    write = m_eCodeDevise};
     __property const Currency   Debit            = { read = GetDebit,         write = m_curDebit};
     __property const Currency   Credit           = { read = GetCredit,        write = m_curCredit};
     __property Currency         Solde            = { read = GetSolde};
     __property bool             EstMouvementeNm1 = { read = m_bMouvementeNm1, write = m_bMouvementeNm1};
     __property Currency         SoldeNm1         = { read = m_curSoldeNm1,    write = m_curSoldeNm1};
     __property bool             EstMouvementeNm2 = { read = m_bMouvementeNm2, write = m_bMouvementeNm2};
     __property Currency         SoldeNm2         = { read = m_curSoldeNm2,    write = m_curSoldeNm2};
     __property bool             EstMouvementeNm3 = { read = m_bMouvementeNm3, write = m_bMouvementeNm3};
     __property Currency         SoldeNm3         = { read = m_curSoldeNm3,    write = m_curSoldeNm3};
     __property bool             EstMouvementeNm4 = { read = m_bMouvementeNm4, write = m_bMouvementeNm4};
     __property Currency         SoldeNm4         = { read = m_curSoldeNm4,    write = m_curSoldeNm4};
     __property bool             RANDetaille      = { read = m_bRANDetaille,   write = m_bRANDetaille};
     __property bool             SaisiePeriodes   = { read = m_bSaisiePeriodes,write = m_bSaisiePeriodes};
     __property bool             Supprime         = { read = m_bSupprime,      write = m_bSupprime};
     __property const AnsiString CompteAbrege     = { read = GetCompteAbrege,  write = SetCompteAbrege};

    public:
     void     __fastcall RAZ();
     CCompte& __fastcall operator = (const CCompte& cptSrc);
    public:
     __fastcall CCompte();
     __fastcall CCompte(const char* pcszCompte, const char* pcszIntitule);
     static bool __fastcall EstUnCompteValide(const char* pcszCompte);
   }; /* class CCompte */

   class cRacineTypeEnr
   {
   public:
    AnsiString strRacine;
    int TypeEnr;
    __fastcall cRacineTypeEnr()
    {
      TypeEnr = 0;
    }
    __fastcall cRacineTypeEnr( const cRacineTypeEnr &RacineTypeEnr)
    {
      strRacine = RacineTypeEnr.strRacine;
      TypeEnr = RacineTypeEnr.TypeEnr;
    }
    bool __fastcall operator <( const cRacineTypeEnr &RacineTypeEnr) const
    {
      if (strRacine == RacineTypeEnr.strRacine)
        return TypeEnr < RacineTypeEnr.TypeEnr;
      else
        return strRacine < RacineTypeEnr.strRacine;
    }
    bool __fastcall operator ==( const cRacineTypeEnr &RacineTypeEnr) const
    {
      return (strRacine == RacineTypeEnr.strRacine) && (TypeEnr == RacineTypeEnr.TypeEnr);
    }
   };
   typedef std::map<cRacineTypeEnr,enum CODE_CYCLE> MapRacineCycle;

   //**********//
   // TTablePC //
   //**********////////////////////////////////////////////////////////////////////
   //                                                                            //
   //    Cette classe permet de gérer un plan comptable (qui contient des        //
   // comptes et un programme de travail).                                       //
   //                                                                            //
   // Clé primaire : Compte + Cycle + TypeEnr                                    //
   ////////////////////////////////////////////////////////////////////////////////
   class TTablePT; // La classe TTablePC en a besoin
   class PACKAGE_COMPTA TTablePC : public CTable
   {
    public:
     #define szfPC_Compte          "Compte"
     #define szfPC_Cycle           "Cycle"
     #define szfPC_TypeEnr         "TypeEnr"      // cf <<enum PC_EnregType>>
     #define szfPC_CodeDevise      "Devise"       // Code de la devise par défaut du compte (CODE_DEVISE_DEFAUT par défaut)
     #define szfPC_Intitule        "Intitule"
     #define szfPC_IntituleLong    "IntituleLong"
     #define szfPC_Lettrable       "Lettrable"
     #define szfPC_Supprime        "Supprime"
     #define szfPC_Visa            "Visa"         // cf <<enum PC_Visa>>
     #define szfPC_Flags           "Flags"        // cf <<enum PC_Flag>>
     #define szfPC_Drapeaux        "Drapeaux"     // Jolis drapeaux bien gérés ( flag mieux géré que Flags)
     #define szfPC_Debit           "Debit"        // Masse des débits de cloture ou de situation suivant la situation (dans la devise du dossier)
     #define szfPC_Credit          "Credit"       //   "    "  crédits    "   "    "    "     "
     #define szfPC_DebitSituation  "DebitSit"     // Masse des débits N jusqu'à la date de situation (dans la devise du dossier)
     #define szfPC_CreditSituation "CreditSit"    //   "    "  crédits N   "   "    "    "     "
     #define szfPC_DebitTotal      "DebitTotal"   // Masse des débits (dans la devise du dossier)
     #define szfPC_CreditTotal     "CreditTotal"  //   "    "  crédits   "   "    "    "     "
     #define szfPC_SoldeNm1        "SoldeNm1"     //   "    "   "   "    "    du dossier
     #define szfPC_SoldeNm2        "SoldeNm2"     //   "    "   "   "    "    du dossier
     #define szfPC_SoldeNm3        "SoldeNm3"     //   "    "   "   "    "    du dossier
     #define szfPC_SoldeNm4        "SoldeNm4"     //   "    "   "   "    "    du dossier
     #define szfPC_CompteOrigine   "CompteO"      // Compte équivalent dans la compta d'origine (si ce compte a été importé)
     #define szfPC_IDImage         "IDImage"
     #define szfPC_SoldeNm1Origine "SoldeNm1O"    // Solde N-1 dans la devise d'origine N-1 (Champ supprimé le 31/10/03)
     #define szfPC_SoldeNm2Origine "SoldeNm2O"    //   "   N-2  "   "    "    d'origine N-2 (Champ supprimé le 31/10/03)
     #define szfPC_CompteAbrege    "CompteAbrege" // Compte abrégé
     static const AnsiString strfPC_Compte;
     static const AnsiString strfPC_Cycle;
     static const AnsiString strfPC_TypeEnr;
     static const AnsiString strfPC_CodeDevise;
     static const AnsiString strfPC_Intitule;
     static const AnsiString strfPC_IntituleLong;
     static const AnsiString strfPC_Lettrable;
     static const AnsiString strfPC_Supprime;
     static const AnsiString strfPC_Visa;
     static const AnsiString strfPC_Flags;
     static const AnsiString strfPC_Drapeaux;
     static const AnsiString strfPC_Debit;
     static const AnsiString strfPC_Credit;
     static const AnsiString strfPC_DebitSituation;
     static const AnsiString strfPC_CreditSituation;
     static const AnsiString strfPC_DebitTotal;
     static const AnsiString strfPC_CreditTotal;
     static const AnsiString strfPC_SoldeNm1;
     static const AnsiString strfPC_SoldeNm2;
     static const AnsiString strfPC_SoldeNm3;
     static const AnsiString strfPC_SoldeNm4;
     static const AnsiString strfPC_CompteOrigine;
     static const AnsiString strfPC_IDImage;
     static const AnsiString strfPC_CompteAbrege;

    public:
     // Valeurs possibles du champ "TypeEnregistrement"
     enum PCTypeEnr {
      PCTYPEENR_COMPTE        = 0,               // L'enregistrement représente un compte
      PCTYPEENR_PROGRAMME_DE_TRAVAIL,            // L'enregistrement représente un programme de travail
      PCTYPEENR_COMPTE_COLLECTIF,                // L'enregistrement représente un compte collectif

      #define NB_PCTYPEENR 3                     //Nombre de valeurs possibles pour le champ 'TypeEnr'
     };
     #define EST_UN_COMPTE(T) ((T) == TTablePC::PCTYPEENR_COMPTE)
     #define EST_UN_COMPTE_COLLECTIF(T) ((T) == TTablePC::PCTYPEENR_COMPTE_COLLECTIF)

     // Définition des valeurs binaires possibles du champ "Flags"
     enum PCFlags {
       PCFLAGS_AUCUN                 = 0x00000000, // Valeur par défaut du champ
       PCFLAGS_COMPTE_CYCLE_FINAL    = 0x00000001, // Ce compte doit figurer dans le cycle final
       PCFLAGS_IMAGE_MODIFIEE        = 0x00000002, // L'image sur le compte a été modifiée
       PCFLAGS_COMPTE_MULTI          = 0x00000004, // Compte multi fournisseur/client (plus de RIB, adresse...)
     };

     enum PCDrapeaux {
       PCDRAPEAUX_AUCUN             = 0x00000000,// Valeur par défaut du champ
       PCDRAPEAUX_COMPTE_AUXILIAIRE = 0x00000001,// L'enregistrement représente un compte collectif

       NB_PCDRAPEAUX = 2                         //Nombre le valeurs possibles pour le champ 'Drapeaux'
     };
     #define EST_AUX(X) ((X) & TTablePC::PCDRAPEAUX_COMPTE_AUXILIAIRE)

     #define EST_UN_COMPTE_NORMAL(T,D) (EST_UN_COMPTE(T) && !EST_AUX(D))
     #define EST_UN_COMPTE_AUXILIAIRE(T,D) (EST_UN_COMPTE(T) && EST_AUX(D))

     // Valeurs possibles du champ "Visa"
     enum PCVisa {
       PCVISA_AUCUN                   = 0x00000000,
       PCVISA_ORDINAIRE_PAR_ORDINAIRE = 0x00000001, // Visa ordinaire posé dans un cycle ordinaire
       PCVISA_ORDINAIRE_PAR_FINAL     = 0x00000002, //  "       "      "    "   le cycle final
       PCVISA_FINAL_PAR_FINAL         = 0x00000004, //  Visa final (posé obligatoirement dans le cycle final)

       PCVISA_PROGRAMME_DE_TRAVAIL    = 0x00000007  // Tous les visas d'un compte
     };
     #define EST_VISE_ORDINAIRE(X) ((X) & TTablePC::PCVISA_ORDINAIRE_PAR_ORDINAIRE)
     #define sziPC_CompteAbrege  "idxCompteAbrege"

    private:
     // Attributs de classe
     static bool         cm_bIsExEuro;           // TRUE si la devise de l'exercice  N   est  l'Euro
    public:
     static AnsiString   cm_strCptPerteArrondis;  // Compte des pertes  sur arrondis Devises Zone Européenne/Euro
     static AnsiString   cm_strCptProfiArrondis;  //   "     "  profits  "     "                 "

     static void __fastcall InitClassMembers( bool             bIsExEuro,
                                              const TDateTime &DateFinExercice,
                                              const TDateTime &DateSituation,
                                              bool Situation);

    // Propriétés redéfinies
    __published:
     __property EICCodeTable = { stored = false}; // Initialisé via constructeur

    // Nouvelles propriétés
    private:
     void     __fastcall SetDrapeaux( bool bValue, PCDrapeaux eIndex);

     Currency __fastcall GetSolde(        int eIDExercice); // Solde N, N-1 ou N-2 du cpt courant
     bool     __fastcall GetEstMouvemente(int eIDExercice); // Cpt courant mouvementé sur N ou N-1 ?
     bool     __fastcall GetEstVise(int bViseFinal);        // Le cpt/PT courant est-il visé (ordinaire ou final) ?
     Currency __fastcall GetResultat();
     Currency __fastcall GetResultatSituation();
      bool __fastcall GetEstUnCompte();
      bool __fastcall GetEstUnCompteNormal();
      bool __fastcall GetEstUnCompteAuxiliaire();
      bool __fastcall GetEstUnProgrammeDeTravail();
     bool     __fastcall GetEstUnCompteCollectif();
     bool     __fastcall GetDrapeaux( int nIndex);

    public:
     // Classe
     __property AnsiString CptPerteArrondis = { read = cm_strCptPerteArrondis};
     __property AnsiString CptProfiArrondis = { read = cm_strCptProfiArrondis};
     __property bool       IsExEuro        = { read = cm_bIsExEuro};

    public:
     __property Currency Solde                 = { read = GetSolde,         index = IDEXERCICE_N};
     __property Currency SoldeNm1              = { read = GetSolde,         index = IDEXERCICE_Nm1};
     __property Currency SoldeNm2              = { read = GetSolde,         index = IDEXERCICE_Nm2};
     __property bool     EstMouvemente         = { read = GetEstMouvemente, index = IDEXERCICE_N};
     __property bool     EstMouvementeNp1      = { read = GetEstMouvemente, index = IDEXERCICE_Np1};
     __property bool     EstMouvementeNm1      = { read = GetEstMouvemente, index = IDEXERCICE_Nm1};
     __property bool     EstMouvementeNm2      = { read = GetEstMouvemente, index = IDEXERCICE_Nm2};
     __property bool     EstMouvementeNm3      = { read = GetEstMouvemente, index = IDEXERCICE_Nm3};
     __property bool     EstMouvementeNm4      = { read = GetEstMouvemente, index = IDEXERCICE_Nm4};
     __property bool     EstViseOrdinaire      = { read = GetEstVise,       index = false}; // Valable pour un PT
     __property bool     EstViseFinal          = { read = GetEstVise,       index = true};  // Valable pour un PT
     __property Currency Resultat              = { read = GetResultat};
     __property Currency ResultatSituation     = { read = GetResultatSituation};
     __property bool     EstDejaMouvemente     = { read = GetEstMouvemente, index = IDEXERCICE_COURANT};
     __property bool     EstUnCompte  = {read = GetEstUnCompte};     //Normal ou auxiliaire
     __property bool     EstUnCompteNormal  = {read = GetEstUnCompteNormal};
     __property bool     EstUnCompteCollectif  = {read = GetEstUnCompteCollectif};
     __property bool     EstUnCompteAuxiliaire  = {read = GetEstUnCompteAuxiliaire};
     __property bool     EstUnProgrammeDeTravail  = {read = GetEstUnProgrammeDeTravail};
     __property bool     EstAuxiliaire = { read = GetDrapeaux, index = PCDRAPEAUX_COMPTE_AUXILIAIRE };

     static bool __fastcall EstLeCollectifDe(const AnsiString &CompteAux,const AnsiString &CompteCollectif);
            void __fastcall SupprimerCompteCollectif( const AnsiString &strCompteCollectif);
    private:
            void            __fastcall OuvrirTableCycles(CTable*& ptblCycles);
     static void            __fastcall FermerTableCycles(CTable*& ptblCycles);

     static enum CODE_CYCLE __fastcall GetPropsUnCompte(MapRacineCycle *mapRacineCycle,
                                                         const AnsiString& strCompte,
                                                         bool&             bIntoCycleFinal);
     /*static enum CODE_CYCLE __fastcall GetPropsUnCompte(CTable*           ptblCycles,
                                                         const AnsiString& strCompte,
                                                         bool&             bIntoCycleFinal);*/
            enum CODE_CYCLE __fastcall GetPropsCompte(const AnsiString& strCompte,
                                                       bool&             bIntoCycleFinal);
     static void __fastcall CreerMapRacineCycle(CTable *ptblCycles,MapRacineCycle *mapRacineCycle);


    //****************************//
    // Opérations sur les comptes //
    //****************************//
    // Les opérations suivantes modifient l'enregistrement courant de la table
    public:
     bool       __fastcall AllerSurLeCompte(const AnsiString& strCompte);        // TRUE si trouvé
     bool       __fastcall AllerSurLeCompteAbrege(const AnsiString& pCompteAbrege); // TRUE si trouvé
     bool __fastcall AllerSurLeCompteCollectif(const AnsiString &Collectif);
     bool       __fastcall AllerSurLeCompteCollectifDe(const AnsiString &Compte);// TRUE si trouvé
     bool       __fastcall GetCompte(const AnsiString& strCompte, CCompte& cpt); // TRUE si trouvé
     bool       __fastcall CreerCompte(const CCompte& cpt);// TRUE si bien inséré (i.e. le cpt n'existe pas déjà)
     bool       __fastcall CreerCompteDlg(EICTag   tag,
                                           bool     bNoCptASaisir, // TRUE si l'utilisateur doit saisir un nouveau n° de cpt
                                           CCompte& cptCree,
                                           void*    hInstance = HInstance); // TRUE si bien créé (i.e. non abandonné par l'utilisateur)
     bool       __fastcall CreerCompteCollectif( const CCompte& cpt, bool bCreate);
     bool __fastcall SupprimerCompte(bool PoserUneQuestion,bool MessageSiNonSupprimable = true);
  bool __fastcall CalculerDebitCreditCollectif(const AnsiString &CompteCollectif);
  void __fastcall CalculerSoldesCollectifs();
  void __fastcall RecalculerSoldesArchive(const AnsiString &NomArchive,int IDExercice);
     void       __fastcall CreerCompteStandard(EICTag             tag,
                                               const AnsiString &Compte,
                                               const AnsiString &Libelle,
                                                void*              hInstance = HInstance); // Le compte devient le compte courant
     void       __fastcall CreerComptesArrondis();
     AnsiString __fastcall CreerCompteRepriseDeDotation(const AnsiString& strCptDotation, bool bCreerCptReprise = true);
     void       __fastcall ModifierCompte(const CCompte& cpt);
     void       __fastcall RAZSoldes(EICTag tag, int eIDExercice, CBarre* pbarre, int hInstance = (int)HInstance);
//     void       __fastcall ImporterCompte(const CCompte& cpt, int eIDExercice);
     void       __fastcall RecalculerCycles(CBarre *Barre = 0,bool ModifierANDetailles = false);
     void __fastcall RecalculerCycle(const AnsiString &Compte,int &Cycle,bool &CycleFinal);
     bool __fastcall ChangerSoldes(bool Situation);
     bool __fastcall EquilibrerNm1Nm2Tenue();
     void __fastcall ConvertirSoldesNm1Nm2TenueEuro( CBarre *pBarre = NULL);

    // Les opérations suivantes ne modifient pas l'enregistrement courant de la table
    public:
     void __fastcall GetCompteCourant(CCompte& cptCourant); // Caractéristiques sur N uniquement
     void __fastcall ViserCompteCourant(bool bViser, bool bVisaFinal);
     bool __fastcall ModifierCompteCourantDlg(EICTag tag, void* hInstance = HInstance); // TRUE s'il y a eu modification


    //************************//
    // Opérations de filtrage //
    //************************//
    public:
     void __fastcall FiltrerCycle(enum CODE_CYCLE eCycle,bool bVoirPT,bool bVoirComptesVises,bool FilteredATrue = false);
     void __fastcall FiltrerProgrammeDeTravail();

    public:
     bool __fastcall EstUnCompteExistant(const AnsiString& strCompte);
     bool __fastcall EstUnCompteAbregeExistant(const AnsiString& pCompteAbrege,const AnsiString& pCompte);
     void __fastcall ChangeSolde(const AnsiString& strCompte,const Currency& curMontant,bool bCredit,const TDateTime &DateOperation,bool Collectif = false);
     // Les opérations suivantes modifient l'enregistrement courant de la table
     bool __fastcall AllerSurLeProgrammeDeTravail(const AnsiString& strRacine);// TRUE si trouvé
     bool __fastcall CreerProgrammeDeTravail(const AnsiString& strRacine,const AnsiString& strDesignation,TTablePT * Table_PT);// TRUE si bien inséré
     bool __fastcall SupprimerAncienPTCommun(TTablePT * Table_PT,CBarre *Barre = 0);
     bool __fastcall RestaurerAncienVisaPTCommun(TTablePT * Table_PT,CBarre *Barre = 0);
     void __fastcall SupprimerProgrammeDeTravail(TTablePT * Table_PT);

     // Les opérations suivantes ne modifient pas l'enregistrement courant de la table
     void __fastcall ViserProgrammeDeTravail(bool bViser,TTablePT * Table_PT = NULL);
    private:
     typedef CTable inherited;
    public:
     __fastcall TTablePC(TComponent* pOwner);
   }; /* class TTablePC */


   //*****************//
   // TChangeResultat //
   //***************************************************************************
   //
   //   Structure avec tous les renseignements pour modifier le résultat
   //   comptable à la date de situation
   //
   //***************************************************************************
  typedef union
    {
      double Double64Bits;
      struct
        {
          int PartieHaute;
          int PartieBasse;
        } Ints32Bits;
    } TChangeResultat;


   //*******************//
   // TLigneEcartChange //
   //***************************************************************************
   //
   //   Structure définissant une ligne d'écriture de l'écart de change.
   //   Utilisée essentiellement dans l'écran Encaissments/Décaissements
   // et dans la classe TEcartChgEcriture.
   //
   //***************************************************************************
#pragma pack(2)
   typedef struct {
     CCompte    Compte;        // N° du compte à créditer ou à débiter
     AnsiString strLibelle;    // Libellé de la ligne d'écriture
     bool       bIsCrediteur;  // Montant créditeur ou débiteur de la ligne
     Currency   curMontant;
     int        nReviseur;
     int        nReference;
   } TLigneEcartChange;
#pragma pack()

   //*******************//
   // TEcartChgEcriture //
   //***************************************************************************
   //
   //   Classe servant à la gestion d'une liste d'écart de change à générer
   // dans une écriture. Chaque élément correspond a une ligne de l'écriture.
   //
   //***************************************************************************
   class PACKAGE_COMPTA TEcartChgEcriture
   {
     private:
       TList *m_pLstEcr;

       int __fastcall GetCount() const;
       TLigneEcartChange *__fastcall GetItems( int nIndex) const;

     public:
       __fastcall  TEcartChgEcriture();
       virtual __fastcall ~TEcartChgEcriture();

       void __fastcall Add( const CCompte &vCompte, const AnsiString &vstrLibelle, bool vbIsCrediteur, const Currency &vcurMontant);
       void __fastcall Add( const TLigneEcartChange &sChange);
       void __fastcall Delete( int nIndex);
       void __fastcall Clear();

       __property int Count = { read=GetCount };
       __property TLigneEcartChange *Items[int nIndex] = { read=GetItems };
   }; /* class TEcartChgEcriture */

#define CUR_MAX (( __int64)0x7FFFFFFFFFFFFFFF)
#pragma pack( 2)
class TLetAuto {
  public:
    Currency  curValue;
    TDateTime dtImput;
    int       nAutoID;
    TCodeDev  Devise;
    double    dTauxChg;
    bool      bUsed;
    bool __fastcall Egal         ( const TLetAuto &pVal2) { return ( curValue==pVal2.curValue); };
    bool __fastcall InferieurEgal( const TLetAuto &pVal2) { return ( curValue<=pVal2.curValue); };
    bool __fastcall IsLast(){ return curValue.Val==CUR_MAX; }
    bool __fastcall IsBusy(){ return bUsed; }
};
#pragma pack()

enum RET_SEARCH { RS_OK, RS_NOK, RS_ABORT };

   //**********//
   // TTableHI //
   //**********////////////////////////////////////////////////////////////////////
   //                                                                            //
   //    Cette classe permet de gérer un historique comptable.                   //
   //                                                                            //
   // Clé primaire : DateImputation + AutoID                                     //
   ////////////////////////////////////////////////////////////////////////////////
   // Composition des code d'origine d'écriture (11=1èreLettre,22=2èmeLettre,33=3èmeLettre,PP=LettrePersonnelle) :
   //                 RAOIDECRITURE     : 0x221100PP
   //                 PRODUCTIDECRITURE : 0xPP332211
   #define STR_MESSAGE_RESULTAT_DATE "COMPTA_CALCULER_RESULTAT_DATE" //Message pour incrémenter le résultat comptable ; WParam = Montant, LParam = Date d'imputation
   #define STR_MESSAGE_RESULTAT_MONTANT "COMPTA_CALCULER_RESULTAT_MONTANT" //Message pour incrémenter le résultat comptable ; WParam = Montant, LParam = Date d'imputation
   #define MAKEPRODUCTIDECRITURE(cProductCodeFirst, cProductCodeSecond, cProductCodeThird, cProductPersonal) (unsigned int)(((cProductCodeFirst)&0xFF)|(((cProductCodeSecond)&0xFF)<<8)|(((cProductCodeThird)&0xFF)<<16)|(((cProductPersonal)&0xFF)<<24))
   #define IS_ARAOIDECRITURE(eRAOIDEcriture)                                                                 (!((eRAOIDEcriture)&0x0000FF00))
   #define IS_THERAOIDECRITURE(cModuleCodeFirst, cModuleCodeSecond, eIDEcriture)                             (((eIDEcriture)&0xFFFFFF00)==MAKERAOIDECRITURE((cModuleCodeFirst), (cModuleCodeSecond), 0x00))
   #define IS_APRODUCTIDECRITURE(eProductIDEcriture)                                                         ((eProductIDEcriture)&0xFF000000)
   #define IS_THEPRODUCTIDECRITURE(cProductCodeFirst, cProductCodeSecond, cProductCodeThird, eIDEcriture)    (((eIDEcriture)&0x00FFFFFF)==MAKEPRODUCTIDECRITURE((cProductCodeFirst), (cProductCodeSecond), (cProductCodeThird), 0x00))
   #define RAOIDECRITURE_PERSONALCODE(eRAOIDEcriture)                                                        (unsigned char)((eRAOIDEcriture)&0x000000FF)
   #define PRODUCTIDECRITURE_PERSONALCODE(eProductIDEcriture)                                                (unsigned char)((eProductIDEcriture)>>24)
   #define RAOIDECRITURE_FONCTION_BASE                                                                        MAKEPRODUCTIDECRITURE(0xFF, 0xFF, 0xFF, 0xFF)
   #define REVAOIDECRITURE(cRevAOPersonal)                                                                   MAKEPRODUCTIDECRITURE(  'R', 'E', 'V', (cRevAOPersonal))
   #define IS_REVAOIDECRITURE(eIDEcriture)                                                                   IS_THEPRODUCTIDECRITURE('R', 'E', 'V', (eIDEcriture))
   #define TENCOIDECRITURE(cTenCoPersonal)                                                                   MAKEPRODUCTIDECRITURE(  'T', 'E', 'N', (cTenCoPersonal))
   #define IS_TENCOIDECRITURE(eIDEcriture)                                                                   IS_THEPRODUCTIDECRITURE('T', 'E', 'N', (eIDEcriture))
   #define INITSOLDEIDECRITURE                                                                               MAKEPRODUCTIDECRITURE( 'S', 'F', 'I', 'S')
   #define SAISIEEXTIDECRITURE                                                                               MAKEPRODUCTIDECRITURE( 'S', 'F', 'E', 'C')


// ATTENTION !!!!
// Ne pas modifier les valeurs des écrans
// car ils sont utilisés dans le HI pour reconnaitre
// de quel écran provient l'écriture
//
// Si ajout de nouvelle valeur vérifier les fonctions suivantes
// 'TfrmDecais::EcritureEstUneFacture' et 'BaseModifierEcritures'
enum TYPE_ECRAN { TE_ENCAISSEMENTS='0', TE_DECAISSEMENTS='1', TE_ANOUVEAUX='2', TE_REMISEBANQUE='3',
                  TE_FORMULAIRE='4', TE_KILOMETRE='5', TE_ACHATS='A', TE_VENTES='G',
                  TE_FACT_AVOIR_FOURN='B', TE_FACT_AVOIR_CLIENTS='H',TE_FORMULAIRE_DEMAT = '6',
                  TE_CLASSIQUE_DEMAT = '7', TE_ENCAISSEMENTS_DEMAT = '8',TE_DECAISSEMENTS_DEMAT = '9' };
// 'A'->'F' : Réservé aux achats
// 'G'->'L' : Réservé aux ventes


   class CEcriture;
   class CPropsEcriture;
   class TTableHITmp;
   class PACKAGE_COMPTA TTableHI : public CTable
   {
    friend class TTableHITmp;
    friend class CEcriture;
    public:
     #define szfHI_DateImputation   "DateImputation"
     #define szfHI_AutoID           "AutoID"           // Auto-incrémenté
     #define szfHI_Compte           "Compte"
     #define szfHI_CodeJournal      "CodeJournal"
     #define szfHI_RANDateOrigine   "RANDateO"         //   Code journal    d'origine pour un RAN détaillé (cf. HIFLAGS_A_NOUVEAU_DETAILLE)
     #define szfHI_RANJnlOrigine    "RANJnlO"          // Date d'imputation     "      "   "   "      "     "               "
     #define szfHI_Piece            "Piece"
     #define szfHI_PieceExterne     "PieceExt"
     #define szfHI_NaturePiece      "NaturePiece"
     #define szfHI_PieceLiee        "PieceLiee"
     #define szfHI_Lettrage         "Lettrage"         // "" par défaut
     #define szfHI_FlagLettrage     "FlagLettrage"     // "Non lettré" par défaut
     #define szfHI_IDEcriture       "IDEcriture"
     #define szfHI_IDEcriturePart   "IDEcriturePart"
     #define szfHI_LibelleOperation "LibelleOperation"
     #define szfHI_MontantOrigine   "MontantO"
     #define szfHI_CodeDevise       "Devise"
     #define szfHI_TauxChange       "Taux"
     #define szfHI_Montant          "Montant"
     #define szfHI_EstCrediteur     "EstCrediteur"     // FALSE par défaut
     #define szfHI_DateEcheance     "DateEcheance"
     #define szfHI_RAOData          "RAOData"
     #define szfHI_RAOIDLigne       "RAOIDLigne"       // Valeur calculée par une macro  MAKERAOIDECRITURE() ou MAKEPRODUCTIDECRITURE()
     #define szfHI_Flags            "Flags"            // 0x00000000 par défaut
     #define szfHI_IDImage          "IDImage"
     #define szfHI_Designation      "Designation"
     #define szfHI_CodeTVA          "CodeTVA"
     #define szfHI_TauxTVA          "TauxTVA"
     #define szfHI_DateEcheance     "DateEcheance"
     #define szfHI_ModePaiement     "ModePaiement"
     #define szfHI_Banque           "Banque"
     #define szfHI_Quantite         "Quantite"
     #define szfHI_CodeAnalytik     "CodeAnalytik"
     #define szfHI_DateEP           "DateEP"
     #define szfHI_Reviseur         "Reviseur"   // Ces 2 colonnes correspondent à la référence unique de la ligne
     #define szfHI_Reference        "Reference"  //
     #define szfHI_DateExport       "DateExport"
     #define szfHI_DateDebPeriode   "DateDebPeriode"
     #define szfHI_DateFinPeriode   "DateFinPeriode"

     static const AnsiString strfHI_DateImputation;
     static const AnsiString strfHI_AutoID;
     static const AnsiString strfHI_Compte;
     static const AnsiString strfHI_CodeJournal;
     static const AnsiString strfHI_RANDateOrigine;
     static const AnsiString strfHI_RANJnlOrigine;
     static const AnsiString strfHI_Piece;
     static const AnsiString strfHI_PieceExterne;
     static const AnsiString strfHI_NaturePiece;
     static const AnsiString strfHI_PieceLiee;
     static const AnsiString strfHI_Lettrage;
     static const AnsiString strfHI_FlagLettrage;
     static const AnsiString strfHI_IDEcriture;
     static const AnsiString strfHI_IDEcriturePart;
     static const AnsiString strfHI_LibelleOperation;
     static const AnsiString strfHI_MontantOrigine;
     static const AnsiString strfHI_CodeDevise;
     static const AnsiString strfHI_TauxChange;
     static const AnsiString strfHI_Montant;
     static const AnsiString strfHI_EstCrediteur;
     static const AnsiString strfHI_DateEcheance;
     static const AnsiString strfHI_RAOData;
     static const AnsiString strfHI_RAOIDLigne;
     static const AnsiString strfHI_Flags;
     static const AnsiString strfHI_IDImage;
     static const AnsiString strfHI_Designation;
     static const AnsiString strfHI_CodeTVA;
     static const AnsiString strfHI_TauxTVA;
     static const AnsiString strfHI_ModePaiement;
     static const AnsiString strfHI_Banque;
     static const AnsiString strfHI_Quantite;
     static const AnsiString strfHI_CodeAnalytik;
     static const AnsiString strfHI_DateEP;
     static const AnsiString strfHI_Reviseur;
     static const AnsiString strfHI_Reference;
     static const AnsiString strfHI_DateExport;
     static const AnsiString strfHI_DateDebPeriode;
     static const AnsiString strfHI_DateFinPeriode;

    //*****************************//
    // Définition des noms d'index //
    //*****************************//
    public:
     #define sziHI_Comptes       "idxComptes"
     #define sziHI_IDEcritures   "idxIDEcritures"
     #define sziHI_CodesJournaux "idxCodesJournaux"
     #define sziHI_RAOIDLignes   "idxRAOIDLignes"
     #define sziHI_LettrageDate  "idxLettrageDate"
     #define sziHI_PakLettrage   "idxPakLettrage"
     static const AnsiString striHI_Comptes;
     static const AnsiString striHI_IDEcritures;


    public:
     // Définition des valeurs combinées possibles du champs "Flags"
     typedef enum HIFlags {
       HIFLAGS_IMPORTEE             = 0x00000000,      // Ligne importée dans l'historique
       HIFLAGS_EST_ANNULEE          = 0x00000001,
       HIFLAGS_EST_NORMALE          = 0x00000002,
       HIFLAGS_LETTRAGE_EST_MODIFIE = 0x00000004,      // Lettrage modifié dans Rev'AO
       HIFLAGS_EST_CORRECTIVE       = 0x00000008,      // Ligne de correction - créée dans Rev'AO - d'une ligne importée (une ligne IMPORTEE+ANNULEE précède OBLIGATOIREMENT)
       HIFLAGS_A_CONTREPASSER       = 0x00000010,      // Ligne à contrepasser (obligatoirement émise par un assistant dans le journal "INVR")
       //HIFLAGS_A_NOUVEAU_DETAILLE   = 0x00000020,      // Ligne d'"A Nouveau" qui représente un détail (avec une date et un journal d'origine du détail) d'un compte "RAN détaillé" plutôt qu'un solde
       HIFLAGS_ECART_ARRONDI        = 0x00000040,      // Ligne d'écart d'arrondi d'une écriture passée dans une devise différente de la devise du dossier
       HIFLAGS_ECART_CHANGE         = 0x00000080,      // Ligne d'écart de change d'une écriture émise par Ten'Co
       HIFLAGS_VALIDEE              = 0x00000100,      // Ligne validée
       HIFLAGS_IMAGE_MODIFIEE       = 0x00000200,      // Image modifiée
       HIFLAGS_PERIODE_EST_MODIFIEE = 0x00000400,      // Période modifiée dans Rev'AO

       HIFLAGS_NORMALE          = HIFLAGS_EST_NORMALE, // Ligne créée normalement par une fonctionnalité de Rev'AO
//faux, ceci n'assure pas que HIFLAGS_EST_NORMALE n'est pas positionné       HIFLAGS_IMPORTEE_ANNULEE = HIFLAGS_EST_ANNULEE, // Ligne importée et annulée (via une écriture)
       HIFLAGS_NORMALE_ANNULEE  = HIFLAGS_EST_ANNULEE |
                                  HIFLAGS_EST_NORMALE, // Ligne normale annulée par une fonctionnalité de Rev'AO

       HIFLAGS_DEFAULT = HIFLAGS_IMPORTEE
     } THIFlags;

     #define LIGNE_EST_ANNULEE(x)             (x & TTableHI::HIFLAGS_EST_ANNULEE     )
     #define LIGNE_EST_IMPORTEE_ANNULEE(x)   ((x & (TTableHI::HIFLAGS_EST_ANNULEE | TTableHI::HIFLAGS_EST_NORMALE)) == TTableHI::HIFLAGS_EST_ANNULEE)
     #define LIGNE_EST_NORMALE(x)            ((x & TTableHI::HIFLAGS_NORMALE         ) == TTableHI::HIFLAGS_NORMALE         )
     #define LIGNE_EST_NORMALE_ANNULEE(x)    ((x & TTableHI::HIFLAGS_NORMALE_ANNULEE ) == TTableHI::HIFLAGS_NORMALE_ANNULEE )
     #define LIGNE_EST_IMPORTEE(x)            (!LIGNE_EST_NORMALE(x))
     #define LIGNE_EST_LETTRAGE_MODIFIE(x)    (x & TTableHI::HIFLAGS_LETTRAGE_EST_MODIFIE)
     #define LIGNE_EST_NORMALE_CORRECTIVE(x) ((x & (TTableHI::HIFLAGS_NORMALE | TTableHI::HIFLAGS_EST_CORRECTIVE)) == (TTableHI::HIFLAGS_NORMALE | TTableHI::HIFLAGS_EST_CORRECTIVE))
     #define LIGNE_EST_ECART_ARRONDI(x)      ((x & TTableHI::HIFLAGS_ECART_ARRONDI   ) == TTableHI::HIFLAGS_ECART_ARRONDI    )
     #define LIGNE_EST_ECART_CHANGE(x)       ((x & TTableHI::HIFLAGS_ECART_CHANGE    ) == TTableHI::HIFLAGS_ECART_CHANGE    )
     #define LIGNE_EST_VALIDEE(x)             (x & TTableHI::HIFLAGS_VALIDEE         )
     #define LIGNE_EST_PERIODE_MODIFIEE(x)    (x & TTableHI::HIFLAGS_PERIODE_EST_MODIFIEE)

     // Définition des valeurs ordinales possibles (short) du champ "FlagLettrage"
     enum HIFlagLettrage {
         HIFLAG_LETTRAGE_LETTRE_IMPORTE = 5,
         HIFLAG_LETTRAGE_LETTRE_IMPORTE_NP1 = 7,
         HIFLAG_LETTRAGE_LETTRE_EIC = 10,
         HIFLAG_LETTRAGE_LETTRE_NP1 = 15,
         HIFLAG_LETTRAGE_PRELETTRE = 20,
         HIFLAG_LETTRAGE_NON_LETTRE = 30,

         HIFLAG_LETTRAGE_DEFAULT = HIFLAG_LETTRAGE_NON_LETTRE,
         NB_HIFLAG_LETTRAGE = 6,                 //Nombre de FlagLettrage pour vérification par le docteur

         HIFLAG_LETTRAGE_EST_LETTRE_N = 100,
         HIFLAG_LETTRAGE_EST_LETTRE_NP1 = 101,
         HIFLAG_LETTRAGE_EST_LETTRE = 102,
         HIFLAG_LETTRAGE_EST_LETTRE_EIC = 103,
         HIFLAG_LETTRAGE_EST_LETTRE_IMPORTE = 104,
       };

     #define LIGNE_EST_LETTRE(x)              ((x == TTableHI::HIFLAG_LETTRAGE_LETTRE_EIC) || (x == TTableHI::HIFLAG_LETTRAGE_LETTRE_IMPORTE))
     #define LIGNE_EST_LETTRE_NP1(x)          ((x == TTableHI::HIFLAG_LETTRAGE_LETTRE_NP1) || (x == TTableHI::HIFLAG_LETTRAGE_LETTRE_IMPORTE_NP1))
     #define LIGNE_EST_LETTRE_EIC(x)          ((x == TTableHI::HIFLAG_LETTRAGE_LETTRE_EIC) || (x == TTableHI::HIFLAG_LETTRAGE_LETTRE_NP1))
     #define LIGNE_EST_PRELETTRE(x)           (x == TTableHI::HIFLAG_LETTRAGE_PRELETTRE)
     #define LIGNE_EST_NON_LETTRE(x)          (x == TTableHI::HIFLAG_LETTRAGE_NON_LETTRE)

     #define COULEUR_LETTRAGE_IMPORTE clBlack
     #define COULEUR_LETTRAGE         clBlue
     #define COULEUR_PRELETTRAGE      clGreen
     #define COULEUR_LETTRAGE_NP1     clOlive

    public:
     enum HIActionDelettrage                     //Types de délettrage possible
      {
        HIAD_DELETTRER_LA_LIGNE = 0,
        HIAD_DELETTRER_LE_TOUT,
        HIAD_DELETTRER_LA_LIGNE_ET_PRELETTRER_LE_RESTE,
        HIAD_PRELETTRER_LE_TOUT,

        HIAD_FIRST = HIAD_DELETTRER_LA_LIGNE,
        HIAD_LAST = HIAD_PRELETTRER_LE_TOUT
       };

     enum HIFiltreLettrage                        //Type de filtrage du lettrage
      {
        HIFL_TOUT = 0,
        HIFL_PRELETTRE_ET_NON_LETTRE,
        HIFL_TOUT_SAUF_PRELETTRAGE_EN_COURS,
        HIFL_NI_LETTRAGE_NI_PRELETTRAGE_EN_COURS,
        HIFL_QUE_PRELETTRAGE_EN_COURS,
        HIFL_LETTRAGE_IMPORTE_ET_LETTRE,
        HIFL_PRELETTRAGE_ET_LETTRE,
        HIFL_RIEN
      };

    private:
      #define STR_HIFLAG_LETTRAGE_LETTRE_IMPORTE "5"
      #if (HIFLAG_LETTRAGE_LETTRE_IMPORTE != 5)
        #pragma error *** STR_HIFLAG_LETTRAGE_LETTRE_IMPORTE a changer en fonction de HIFLAG_LETTRAGE_LETTRE_IMPORTE ***
      #endif
      #define STR_HIFLAG_LETTRAGE_LETTRE "10"
      #if (HIFLAG_LETTRAGE_LETTRE != 10)
        #pragma error *** STR_HIFLAG_LETTRAGE_LETTRE a changer en fonction de HIFLAG_LETTRAGE_LETTRE ***
      #endif
      #define STR_HIFLAG_LETTRAGE_LETTRE_NP1 "15"
      #if (HIFLAG_LETTRAGE_LETTRE_NP1 != 15)
        #pragma error *** STR_HIFLAG_LETTRAGE_LETTRE_NP1 a changer en fonction de HIFLAG_LETTRAGE_LETTRE_NP1 ***
      #endif
      #define STR_HIFLAG_LETTRAGE_PRELETTRE "20"
      #if (HIFLAG_LETTRAGE_PRELETTRE != 20)
        #pragma error *** STR_HIFLAG_LETTRAGE_PRELETTRE a changer en fonction de HIFLAG_LETTRAGE_PRELETTRE ***
      #endif
      #define STR_HIFLAG_LETTRAGE_NON_LETTRE "30"
      #if (HIFLAG_LETTRAGE_NON_LETTRE != 30)
        #pragma error *** STR_HIFLAG_LETTRAGE_NON_LETTRE a changer en fonction de HIFLAG_LETTRAGE_NON_LETTRE ***
      #endif

      #define CARACTERE_PRELETTRAGE     '#'
      #define STR_CARACTERE_PRELETTRAGE "#"
      #define STR_PREMIERE_LETTRE       "A"
      #define STR_DERNIERE_LETTRE       "ZZ"

    private:
     typedef CTable inherited;

     typedef void __fastcall ( __closure *TIncProgressBar)();

     //**************************************************************//
     // Fonctions et variables utilisées par le lettrage automatique //
     //**************************************************************//
     static AnsiString        m_strCompteALettrer;  // Numéro du compte en cours de traitement
     static int               m_nRecurs;            // Profondeur de recherche des lettrages
     static TList            *m_pSoluce;            // Liste des RecNo de la solution
     static TfrmLettrageAuto *m_frmLettrageAuto;    // Fenêtre de progression du lettrage
     bool              m_bDelLettrage;
     void       __fastcall LettrerAutoOnFilterRecord( TDataSet *pDataSet, bool &bAccept);
     bool       __fastcall ChercherLettrage( TLetAuto *pDebit, TLetAuto *pCredit, TIncProgressBar pIncFnc);
     RET_SEARCH __fastcall ChercherSomme( const TLetAuto &laValue, TLetAuto *pArray,bool &Np1);
     bool       __fastcall LettrageAutomatique();

     static CTable        *m_pTable;
     static TIntegerField *m_pfldIDMaster;
     static TIntegerField *m_pfldIDInc;
     static int m_nCountInstance;
     static int m_nReviseur;

     static int __fastcall GetReferenceSuivante( void);

    public:
      __fastcall TTableHI(TComponent* pOwner);

     static void __fastcall ( *m_fncAccepterEcriture)( const TDateTime&);

    protected:
      virtual void __fastcall InternalOpen ( void);
      virtual void __fastcall InternalClose( void);

    // Propriétés redéfinies
    __published:
     __property EICCodeTable = { stored = false}; // Initialisé via constructeur

    // Nouvelles propriétés
    // Ces propriétés s'appliquent à la ligne courante de l'historique
    public:
     __property int  AutoID             = { read = GetAutoID};
     __property bool EstCrediteur       = { read = GetEstCrediteur, write = SetEstCrediteur};
     __property bool EstUneLigneAnnulee = { read = GetEstUneLigneAnnulee};
     __property bool EstLettreEICN = { read = GetEstLettre, index = HIFLAG_LETTRAGE_LETTRE_EIC};
     __property bool EstLettreImporteN = { read = GetEstLettre, index = HIFLAG_LETTRAGE_LETTRE_IMPORTE};
     __property bool EstLettreN = { read = GetEstLettre, index = HIFLAG_LETTRAGE_EST_LETTRE_N};
     __property bool EstLettreEICNp1 = { read = GetEstLettre, index = HIFLAG_LETTRAGE_LETTRE_NP1};
     __property bool EstLettreImporteNp1 = { read = GetEstLettre, index = HIFLAG_LETTRAGE_LETTRE_IMPORTE_NP1};
     __property bool EstLettreNp1 = { read = GetEstLettre, index = HIFLAG_LETTRAGE_EST_LETTRE_NP1};
     __property bool EstLettre = { read = GetEstLettre, index = HIFLAG_LETTRAGE_EST_LETTRE};
     __property bool EstLettreEIC = { read = GetEstLettre, index = HIFLAG_LETTRAGE_EST_LETTRE_EIC};
     __property bool EstLettreImporte = { read = GetEstLettre, index = HIFLAG_LETTRAGE_EST_LETTRE_IMPORTE};
     __property bool EstPrelettre = { read = GetEstLettre, index = HIFLAG_LETTRAGE_PRELETTRE};
     __property bool EstNonLettre = { read = GetEstLettre, index = HIFLAG_LETTRAGE_NON_LETTRE};
     __property bool LettrageEstModifie = { read = GetLettrageEstModifie};
     __property bool EstLignePointee = { read = GetEstLignePointee };
     __property bool EstLigneValidee = { read = GetEstLigneValidee };

    private:
     int  __fastcall GetAutoID();                     // ID autoincrémenté de l'enregistrement courant
     bool __fastcall GetEstCrediteur();               // Le montant courant est-il créditeur ?
     void __fastcall SetEstCrediteur(bool bEstCrediteur);
     bool __fastcall GetEstUneLigneAnnulee();         // La ligne courante est-elle annulée ?
     bool __fastcall GetEstLettre(int eTypeLettrage);
     bool __fastcall GetLettrageEstModifie();
     bool __fastcall GetEstLignePointee();
     bool __fastcall GetEstLigneValidee();

     void __fastcall SetLettrageEstModifie(bool bEstModifie);

    // Les opérations suivantes ne modifient pas l'enregistrement courant de la table
    private:
     int  __fastcall CreerIDNouvelleEcriture();
     void __fastcall AnnulerEcritureSansTest( int nID, TTablePC* ptblPC, CTable *ptblHI2, int *nNewID, bool bSupprLettrage);

    // Les opérations suivantes modifient l'enregistrement courant de la table
    private:
     typedef std::list<AnsiString> TListComptes; // Liste des comptes dont les lignes ont été détruites physiquement
     void __fastcall RAZCptNonMouvementes(TTablePC* ptblPC,TListComptes& lstcptDetruits);
     void __fastcall AnnulerLigne(TTablePC* ptblPC, CTable* ptblHI2,int nIDEcrRectifiee,bool& bEtaitImportee,TListComptes& lstcptDeleted);
     void __fastcall TransfererLigne(CTable *tblHI2,int nIDEcrDst);
     class LettragesAModifier
     {
     public:
      AnsiString Compte,Lettrage;
      enum HIFlagLettrage FlagLettrage;
      __fastcall LettragesAModifier()
        {
          Compte = Lettrage = EmptyStr;
          FlagLettrage = HIFLAG_LETTRAGE_NON_LETTRE;
        }
      __fastcall ~LettragesAModifier()
        {
        }
      __fastcall LettragesAModifier(const LettragesAModifier &lam)
        {
          Compte = lam.Compte;
          Lettrage = lam.Lettrage;
          FlagLettrage = lam.FlagLettrage;
        }
     };
     typedef std::list<LettragesAModifier> TListLettragesAModifier;
     void __fastcall AjouterLigneDe(TTableHITmp*          ptblHITmp,
                                    const CPropsEcriture& cpe,
                                    TTablePC*             ptblPC,
                                    CTable*               ptblHI2,
                                    bool                  bEstCorrective,
                                    int                   nReviseur = 0,
                                    int                   nRef = 0,
                                    TListLettragesAModifier *lLettragesAModifier = NULL);
     void __fastcall AjouterEcartArrondi(const CPropsEcriture& cpe,
                                         TTablePC*             ptblPC,
                                         CTable               *ptblHI2,
                                         const Currency&       curEcartArr);
     void __fastcall AjouterEcartsChange( const CPropsEcriture    &cpe,
                                          TTablePC                *ptblPC,
                                          CTable                  *ptblHI2,
                                          const TEcartChgEcriture *pEcartCh);
     void __fastcall RectifierEcriture(int                   nIDEcrOrigine,
                                       const CPropsEcriture& cpeRectifiee,
                                       TTableHITmp*          ptblHITmp,
                                       TTablePC*             ptblPC,
                                       CTable*               ptblHI2,
                                       CBarre*               pbarre);
     void __fastcall SupprimerAncienLettrageNp1(TTablePC *tblPC,const TDateTime &DateFinExNp1,CBarre *Barre);
     void __fastcall AjouterListeLettrage(TList *ListeAutoID,const AnsiString &Lettrage,bool LettrageNp1) const;
     void __fastcall LettrerListeLettrage();
     void        __fastcall LettrerPrelettrageEquilibreQuick(const AnsiString &strLettre,const TList *pListeRecNo);
     bool __fastcall LettrageCombinatoire(unsigned int Profondeur);
     bool __fastcall LettrageCombinatoire(unsigned int Profondeur,unsigned int ProfondeurMax,AnsiString &Lettrage);
    public:
     bool __fastcall EstJnlMouvemente(const AnsiString& strCodeJnl);
     void __fastcall Cloturer(const TDateTime &dateFinExN,
                              const TDateTime &dateFinExNp1,
                              const AnsiString &strJnlANouveau,
                              const AnsiString &CompteResultatPerte,
                              const AnsiString &CompteResultatBenefice,
                              TTableHI *ptblHINp1,
                              TTablePC *ptblPC,
                              TTable *tblNotes,
                              TTableHI *tblINVR,
                              CTable   *ptblHI2,
                              CTable   *tblHI2Np1,
                              bool ANEnDetail,
                              CBarre *pBarre);
     void __fastcall RecalculerSoldeN(TTablePC *tblPC,const TDateTime &AncienneDateFinEx,const TDateTime &NouvelleDateFinEx);
     Currency    __fastcall ObtenirSolde();
     bool        __fastcall AnnulerEcriture(int nID, TTablePC* TablePC, CTable *ptblHI2, int *nNewID = NULL, bool bSupprLettrage = true);
     Currency    __fastcall ResultatSituation(const TDateTime &DateSituation,bool AvecBarre = true);
     void        __fastcall Lettrer(const AnsiString &Lettre,bool Np1);
     void        __fastcall LettrerAutomatique(const AnsiString &strCompte, TYPE_LETTRAGE *tLettrage, int *Recurs, CTable *ptblHI2);
     void        __fastcall Prelettrer(const AnsiString &Lettre);
     void        __fastcall Delettrer(enum HIActionDelettrage eActionDelettrage = HIAD_DELETTRER_LA_LIGNE);
     void        __fastcall LettrerPrelettrageEquilibre(const AnsiString &strCompte,const AnsiString &Prelettre,const AnsiString &Lettre,bool bCreateFilter=true);
     AnsiString  __fastcall LettrageSuivant(const AnsiString &strCompte);
     AnsiString  __fastcall PrelettrageSuivant(const AnsiString &strCompte);
     bool __fastcall ReclasserLettrages(const AnsiString &ComptesAReclasser = EmptyStr,CBarre *Barre = NULL);
     static void __fastcall IncLettre(AnsiString &strLettre);
     static void __fastcall DrawLettrage(TDBGrid *Sender,const TRect &Rect,int DataCol,TColumn* Column,TGridDrawState State,enum HIFlagLettrage FlagLettrage);
     void        __fastcall FiltrerLettrage(enum HIFiltreLettrage TypeFiltre,const AnsiString &Lettre = EmptyStr);
     void        __fastcall FiltrerLettrage(const AnsiString &Compte,const AnsiString &Lettre,enum HIFlagLettrage TypeLettrage);
     bool        __fastcall LettrageTotalementDans( const TDateTime &DateDeb, const TDateTime &DateFin, const AnsiString &Compte, const AnsiString &Lettre, enum HIFlagLettrage TypeLettrage);
     void        __fastcall ChangeIDEcriture( int nCurID, int nNewID);
     bool __fastcall TransfererCompte(TTableHITmp *tblHITmp,TTablePC *tblPC,CTable *tblHI2,const AnsiString &Compte1,const AnsiString &Compte2,bool TransfererTout,TList *pListeAutoIdTransferes,const TDateTime &dtDateFinTransfert = 0, bool bEntreprise = false);
     void        __fastcall FiltrerLettrageRange(const AnsiString &Compte,const AnsiString &Lettre,enum HIFlagLettrage TypeLettrage);
     TTableHI* __fastcall CreerTableLettrage(TStringField **fCompte,TIntegerField **fFlagLettrage,TStringField **fLettrage,TDateTimeField **fDateImputation);
     bool        __fastcall EstEcriturePointee( int nIDEcr);
     bool        __fastcall EstEcritureValidee( int nIDEcr);
     void        __fastcall ValidationEcriture( int nIDEcr);
     void        __fastcall GenerateReferences( void);

     static void __fastcall SetCodeReviseur( int nCode);
   }; /* class TTableHI */



   //****************//
   // CPropsEcriture //
   //****************//
   class PACKAGE_COMPTA CPropsEcriture : public TObject
   {
    private:
     int                m_nIDEcriture;    // ID de l'écriture
     TTableHI::THIFlags m_eFlags;
     const CDevise&     m_devEcriture;    // Devise de l'écriture
     TCodeDev           m_eCodeDevise;    // Code de la devise
     bool               m_bDeviseEuroNat; // TRUE si la devise est la devise nationale (qui disparaîtra en 2002) d'une nation Européenne
     double             m_dblTxChgDevise; // Taux de change de la devise (ignoré pour une devise Euro)
     const AnsiString&  m_strCodeJnl;
     const TDateTime&   m_dateImputation;
     unsigned int       m_eRAOIDLigne;    // ID du module ou du produit qui a généré la ligne
     bool               m_bPieceConst;    // TRUE si la pièce est constante sur l'écriture
     const AnsiString&  m_strPieceConst;  // Pièce constante de l'écriture (ignorée si !m_bPieceConst)
     const AnsiString&  m_strNaturePiece;
     const AnsiString &m_IDEcriturePart;
    public:
     __property int                IDEcriture        = { read = m_nIDEcriture};
     __property TTableHI::THIFlags Flags             = { read = m_eFlags};
     __property const CDevise&     Devise            = { read = m_devEcriture};
     __property TCodeDev           CodeDevise        = { read = m_eCodeDevise};
     __property bool               EstDeviseEuroNat  = { read = m_bDeviseEuroNat};
     __property double             TauxChangeDevise  = { read = m_dblTxChgDevise};
     __property const AnsiString&  CodeJournal       = { read = m_strCodeJnl};
     __property const TDateTime&   DateImputation    = { read = m_dateImputation};
     __property bool               EstPieceConstante = { read = m_bPieceConst};
     __property const AnsiString&  PieceConstante    = { read = m_strPieceConst};
     __property const AnsiString&  NaturePiece       = { read = m_strNaturePiece};
     __property unsigned int       RAOIDLigne        = { read = m_eRAOIDLigne};
     __property const AnsiString &IDEcriturePart = {read = m_IDEcriturePart};


    public:
     friend TTableHI& __fastcall operator<<(TTableHI& tblHI, const CPropsEcriture& pe);
     friend CTable&   __fastcall operator<<(CTable& tblHI2, const CPropsEcriture& pe);
     void __fastcall InitHIPieceFrom(TTableHI* ptblHI, TTableHITmp* ptblHITmp) const;
     __fastcall CPropsEcriture(int                nIDEcriture,
                                TTableHI::THIFlags eFlags,
                                const CDevise&     devEcriture,
                                const AnsiString&  strCodeJnl,
                                const TDateTime&   dateImputation,
                                bool               bPieceConst,
                                const AnsiString&  strPieceConst,
                                const AnsiString&  strNaturePiece,
                                unsigned int       eRAOIDLigne,
                                const AnsiString &strIDEcriturePart);
   }; /* class CPropsEcriture */


   //*************//
   // TTableHITmp //
   //*************//
   class PACKAGE_COMPTA TTableHITmp : public CTable
   {
    friend class TTableHI;
    public:
     #define szfHITmp_Compte           "Compte"
     #define szfHITmp_LibelleOperation "LibelleOperation"
     #define szfHITmp_Piece            "Piece"
     #define szfHITmp_PieceExterne     "PieceExterne"
     #define szfHITmp_Debit            "Debit"
     #define szfHITmp_Credit           "Credit"
     #define szfHITmp_IDLigne          "IDLigne"
     #define szfHITmp_Lettrage         "Lettrage"
     #define szfHITmp_FlagLettrage     "FlagLettrage"
     #define szfHITmp_RAOData          "RAOData"
     #define szfHITmp_RAOIDLigne       "RAOIDLigne"
     #define szfHITmp_EstNouvelleLigne "EstNouvelleLigne" // TRUE par défaut
     #define szfHITmp_Designation      "Designation"
     #define szfHITmp_CodeTVA          "CodeTVA"
     #define szfHITmp_TauxTVA          "TauxTVA"
     #define szfHITmp_DateEcheance     "DateEcheance"
     #define szfHITmp_ModePaiement     "ModePaiement"
     #define szfHITmp_Banque           "Banque"
     #define szfHITmp_Quantite         "Quantite"
     #define szfHITmp_CodeAnalytik     "CodeAnalytik"
     #define szfHITmp_DateEP           "DateEP"
     #define szfHITmp_IDImage          "IDImage"
     #define szfHITmp_IDImageModifie   "IDImageModifie"
     #define szfHITmp_DateDebPeriode   "DateDebPeriode"
     #define szfHITmp_DateFinPeriode   "DateFinPeriode"

     static const AnsiString strfHITmp_Compte;
     static const AnsiString strfHITmp_LibelleOperation;
     static const AnsiString strfHITmp_Piece;
     static const AnsiString strfHITmp_PieceExterne;
     static const AnsiString strfHITmp_Debit;
     static const AnsiString strfHITmp_Credit;
     static const AnsiString strfHITmp_IDLigne;
     static const AnsiString strfHITmp_Lettrage;
     static const AnsiString strfHITmp_FlagLettrage;
     static const AnsiString strfHITmp_RAOData;
     static const AnsiString strfHITmp_RAOIDLigne;
     static const AnsiString strfHITmp_EstNouvelleLigne;
     static const AnsiString strfHITmp_Designation;
     static const AnsiString strfHITmp_CodeTVA;
     static const AnsiString strfHITmp_TauxTVA;
     static const AnsiString strfHITmp_DateEcheance;
     static const AnsiString strfHITmp_ModePaiement;
     static const AnsiString strfHITmp_Banque;
     static const AnsiString strfHITmp_Quantite;
     static const AnsiString strfHITmp_CodeAnalytik;
     static const AnsiString strfHITmp_DateEP;
     static const AnsiString strfHITmp_IDImage;
     static const AnsiString strfHITmp_IDImageModifie;
     static const AnsiString strfHITmp_DateDebPeriode;
     static const AnsiString strfHITmp_DateFinPeriode;

    // Propriétés redéfinies
    __published:
     __property EICTypeTable = { default = ttTmp, stored = false}; // Initialisé via constructeur
     __property Exclusive    = { default = true,  stored = false}; // Initialisé via constructeur
     __property TableName    = {                  stored = false}; // Initialisé via constructeur

    private:
     // Les opérations suivantes ne modifient pas la ligne courante
     bool __fastcall ContientLaLigneDOrigine(int nIDLigneOrigine, bool& bEstLaLigneCourante);

    public:
     // Les opérations suivantes modifient la ligne courante
     bool __fastcall CopyEcritureFrom( int                nIDEcriture,    // ID de l'écriture à recopier
                                       TTableHI*          ptblHISrc,      // HI dans lequel prendre l'écriture
                                       CTable*            ptblHI2,        // HI dans lequel prendre l'écriture
                                       CDevise&           devEcriture,    // Retourne la devise de l'écriture
                                       TDateTime&         dateImputation, //    "     la date d'imputation de l'écriture
                                       AnsiString&        strCodeJnl,     //    "     le code journal de l'écriture
                                       bool&              bPieceConst,    //    "     TRUE si la pièce de l'écriture est constante sur toutes ses lignes
                                       AnsiString&        strPieceConst,  //    "     la pièce constante de l'écriture (à ignorer si bPieceConstante == false)
                                       AnsiString&        strNaturePiece, //    "     la nature de la pièce de l'écriture
                                       bool&              bAnnulee,       //    "     TRUE si l'écriture ne contient que des lignes annulées
                                       TEcartChgEcriture *pEcartCh,       //    "     les lignes d'écart de change sauf si pointeur NULL
                                       AnsiString &IDEcriturePart,
                                       CBarre*            pbarre); /* TRUE si écriture modifiable i.e. non annulée */

     void __fastcall ValideEcriture( int                      nID,             // IdEcritureNouvelle pour nouvelle
                                     unsigned int             eIDRAO,          // Valeur MAKERAOIDECRITURE() ou MAKEPRODUCTIDECRITURE()
                                     TTableHI::THIFlags       eHIFlagEcriture, // TTableHI::HIFLAGS_IMPORTEE/NORMALE
                                     const CDevise&           devEcriture,     // Devise de l'écriture
                                     const TDateTime&         dtImputation,
                                     const AnsiString&        strCodeJournal,
                                     bool                     bPieceConst,     // TRUE si la pièce de l'écriture est constante sur toutes ses lignes
                                     const AnsiString&        strPieceConst,   // Pièce constante de l'écriture (ignorée si bPieceConstante == false)
                                     const AnsiString&        strNaturePiece,  // "" (ou EmptyStr) pour aucune
                                     const TEcartChgEcriture *pEcartCh,
                                     TTableHI*                TableHI,
                                     CTable*                  ptblHI2Dst,
                                     TTablePC*                TablePC,
                                     const AnsiString &IDEcriturePart,
                                     CBarre*                  pbarre, /* = NULL */
                                     int*                     pnIDEcrValidee = NULL /* Retourne le n° de l'écriture validée */);
      static void __fastcall VerifierINV(const AnsiString &Journal,const TDateTime &DateImputation);
    private:
     typedef CTable inherited;
    public:
     __fastcall TTableHITmp(TComponent* pOwner);
   }; /* class TTableHITmp */



   //**********//
   // TTablePT //
   //**********///////////////////////////////////////////////////////////////
   //                                                                       //
   //    Cette classe encapsule les traitements relatifs aux consignes du   //
   //    programmes de travail.                                             //
   ///////////////////////////////////////////////////////////////////////////
   class PACKAGE_COMPTA TTablePT : public CTable
   {
    friend TTablePC;
    public:
     #define szfPT_Racine        "Racine"
     #define szfPT_Ordre         "Ordre"
     #define szfPT_TypeCondition "TypeCondition"           // cf <<enum PT_TypeCondition>>
     #define szfPT_Consigne      "Consigne"
     #define szfPT_Visa          "Visa"
     static const AnsiString strfPT_Racine;
     static const AnsiString strfPT_Ordre;
     static const AnsiString strfPT_TypeCondition;
     static const AnsiString strfPT_Consigne;
     static const AnsiString strfPT_Visa;
    public:
     // Valeurs possibles du champ "TypeCondition"
     enum PTTypeCondition
      {
        PTTYPECONDITION_INCONDITIONNEL_COMMUN = 0,  //L'enregistrement représente une consigne commune obligatoire
/*Non utilisé*/PTTYPECONDITION_CONDITIONNEL_COMMUN,        //L'enregistrement représente une consigne commune conditionnelle à la présence de compte
        PTTYPECONDITION_DOSSIER,                    //L'enregistrement représente une consigne du dossier
        PTTYPECONDITION_ANCIEN_COMMUN               //L'enregistrement représente une ancienne consigne (juste le temps de la MAJ)
      };

    private:
     typedef CTable inherited;
    public:
     __fastcall TTablePT(TComponent* pOwner);


    // Propriétés redéfinies
    __published:
     __property EICCodeTable = { stored = false}; // Initialisé via constructeur

    // Nouvelles propriétés
    private:
     bool       __fastcall GetEstVise();        // true si le programme de travail est visé
     AnsiString __fastcall GetMemo();
     void       __fastcall SetMemo(AnsiString& Texte);
     int        __fastcall OrdreSuivant(PTTypeCondition TypeCond);

    public:
     __property bool       EstVise  = { read = GetEstVise};
     __property AnsiString Resultat = { read = GetMemo,    write = SetMemo};

    // Les opérations suivantes modifient l'enregistrement courant de la table
    protected:
     bool __fastcall SupprimerAncienPTCommun(CBarre *Barre = 0);
     bool __fastcall RestaurerAncienVisaPTCommun(CBarre *Barre = 0);
    public:
     bool __fastcall CreerConsigne(const AnsiString &Racine,const AnsiString &Consigne,PTTypeCondition TypeCondition = PTTYPECONDITION_DOSSIER);
     bool __fastcall EstToutVise(const AnsiString &Racine,bool *RacineVide = NULL);
     void __fastcall SupprimerConsignes(AnsiString & Racine);
     void __fastcall SupprimerConsigne();
    private:
     void __fastcall fmFiltrerComptesMouvementes(TDataSet *DataSet, bool &Accept);

    // Les opérations suivantes ne modifient pas l'enregistrement courant de la table
    public:
     void __fastcall ViserConsigne(bool bViser);
     void __fastcall ViserRacine(const AnsiString &Racine,bool bViser);
     bool __fastcall MonterConsigne();
     bool __fastcall DescendreConsigne();
    private:
     bool __fastcall ComptesMouvementes(TTablePC * Table_PC);


    //************************//
    // Opérations de filtrage //
    //************************//
    public:
     void __fastcall FiltrerRacine(const AnsiString& Racine);
     void __fastcall FiltrerComptesMouvementes(TTablePC * Table_PC);
   }; /* class TTablePT */

   class PACKAGE_COMPTA CLigneEcriture
   {
     private:
       AnsiString               m_strCompte;
       TDateTime                m_dateRANOrigine;
       AnsiString               m_strRANJournalOrigine;
       AnsiString               m_strPiece;
       AnsiString               m_strLettrage;
       TTableHI::HIFlagLettrage m_nFlagLettrage;
       AnsiString               m_strLibelleOperation;
       Currency                 m_curMontantOrgine;
       TCodeDev                 m_codeDevise;
       double                   m_dTaux;
       bool                     m_bEstCrediteur;
       int                      m_nFlags;
       AnsiString               m_strIDEcriturePart;
       AnsiString               m_strRAOData;
       TDateTime                m_dtDateDebPeriode;
       TDateTime                m_dtDateFinPeriode;
       int                      m_nIDImage;
       AnsiString               m_strDesignation;
       TDateTime                m_dtDateEcheance;
       double                   m_dQuantite;
       AnsiString               m_strBanquePaiement;
       MODE_PAIEMENT            m_eModePaiement;
       double                   m_dTauxTVA;
       AnsiString               m_strCodeTVA;
       AnsiString               m_strNaturePiece;
       AnsiString               m_strPieceExt;
       AnsiString               m_strAnalyt;
       TDateTime                m_dtRapprochement;
       int                      m_nReviseur;
       int                      m_nReference;

       void __fastcall Init( const AnsiString &strCompte, const AnsiString &strLibelleOp, bool bEstCrediteur, const Currency &curMontantOrigine, TCodeDev eCodeDevise, double dTaux, const AnsiString &strPiece, const AnsiString &strNaturePiece, const AnsiString &strPieceExt);

     public:
       __fastcall CLigneEcriture( const AnsiString &strCompte, const AnsiString &strLibelleOp, bool bEstCrediteur, const Currency &curMontantOrigine, const AnsiString &strPiece = EmptyStr, const AnsiString &strNaturePiece = EmptyStr, const AnsiString &strPieceExt = EmptyStr);
       __fastcall CLigneEcriture( const AnsiString &strCompte, const AnsiString &strLibelleOp, bool bEstCrediteur, const Currency &curMontantOrigine, TCodeDev eCodeDevise, double dTaux, const AnsiString &strPiece = EmptyStr, const AnsiString &strNaturePiece = EmptyStr, const AnsiString &strPieceExt = EmptyStr);

       __property AnsiString               Compte            = { read=m_strCompte           , write=m_strCompte            };
       __property TDateTime                RANDateOrigine    = { read=m_dateRANOrigine      , write=m_dateRANOrigine       };
       __property AnsiString               RANJournalOrigine = { read=m_strRANJournalOrigine, write=m_strRANJournalOrigine };
       __property AnsiString               Piece             = { read=m_strPiece            , write=m_strPiece             };
       __property AnsiString               Lettrage          = { read=m_strLettrage         , write=m_strLettrage          };
       __property TTableHI::HIFlagLettrage FlagLettrage      = { read=m_nFlagLettrage       , write=m_nFlagLettrage        };
       __property AnsiString               LibelleOperation  = { read=m_strLibelleOperation , write=m_strLibelleOperation  };
       __property Currency                 MontantOrigine    = { read=m_curMontantOrgine    , write=m_curMontantOrgine     };
       __property TCodeDev                 CodeDevise        = { read=m_codeDevise          , write=m_codeDevise           };
       __property double                   Taux              = { read=m_dTaux               , write=m_dTaux                };
       __property bool                     EstCrediteur      = { read=m_bEstCrediteur       , write=m_bEstCrediteur        };
       __property int                      Flags             = { read=m_nFlags              , write=m_nFlags               };
       __property AnsiString               IDEcriturePart    = { read=m_strIDEcriturePart   , write=m_strIDEcriturePart    };
       __property AnsiString               RAOData           = { read=m_strRAOData          , write=m_strRAOData           };
       __property TDateTime                DateDebPeriode    = { read=m_dtDateDebPeriode    , write=m_dtDateDebPeriode     };
       __property TDateTime                DateFinPeriode    = { read=m_dtDateFinPeriode    , write=m_dtDateFinPeriode     };
       __property int                      IDImage           = { read=m_nIDImage            , write=m_nIDImage             };
       __property AnsiString               Designation       = { read=m_strDesignation      , write=m_strDesignation       };
       __property TDateTime                DateEcheance      = { read=m_dtDateEcheance      , write=m_dtDateEcheance       };
       __property double                   Quantite          = { read=m_dQuantite           , write=m_dQuantite            };
       __property AnsiString               BanquePaiement    = { read=m_strBanquePaiement   , write=m_strBanquePaiement    };
       __property MODE_PAIEMENT            ModePaiement      = { read=m_eModePaiement       , write=m_eModePaiement        };
       __property double                   TauxTVA           = { read=m_dTauxTVA            , write=m_dTauxTVA             };
       __property AnsiString               CodeTVA           = { read=m_strCodeTVA          , write=m_strCodeTVA           };
       __property AnsiString               NaturePiece       = { read=m_strNaturePiece      , write=m_strNaturePiece       };
       __property AnsiString               PieceExterne      = { read=m_strPieceExt         , write=m_strPieceExt          };
       __property AnsiString               CodeAnalytique    = { read=m_strAnalyt           , write=m_strAnalyt            };
       __property TDateTime                DateRapprochement = { read=m_dtRapprochement     , write=m_dtRapprochement      };
       __property int                      Reviseur          = { read=m_nReviseur           , write=m_nReviseur            };
       __property int                      Reference         = { read=m_nReference          , write=m_nReference           };
   };


   class PACKAGE_COMPTA CLignesEcriture
   {
     private:
       TList *m_pEcr;
       int __fastcall GetCount() const;
       CLigneEcriture *GetLigneEcriture( int nIndex) const;

     public:
       __fastcall  CLignesEcriture();
       virtual __fastcall ~CLignesEcriture();

       int  __fastcall Add( const AnsiString &strCompte, const AnsiString &strLibelleOp, bool bEstCrediteur, const Currency &curMontantOrigine, const AnsiString &strPiece = EmptyStr, const AnsiString &strNaturePiece = EmptyStr, const AnsiString &strPieceExt = EmptyStr);
       int  __fastcall Add( const AnsiString &strCompte, const AnsiString &strLibelleOp, bool bEstCrediteur, const Currency &curMontantOrigine, TCodeDev eCodeDevise, double dTaux, const AnsiString &strPiece = EmptyStr, const AnsiString &strNaturePiece = EmptyStr, const AnsiString &strPieceExt = EmptyStr);
       void __fastcall Clear();
       void __fastcall Delete( int nIndex);

       __property int Count = { read=GetCount };
       __property CLigneEcriture *Ligne[int nIndex] = { read=GetLigneEcriture };
   };


   class PACKAGE_COMPTA CEcriture
   {
     private:
       // Liste des valeurs communes à l'écriture
       TDateTime        m_dateImputation;
       AnsiString       m_strCodeJournal;
       TCodeDev         m_codeDevise;
       double           m_dTaux;
       int              m_nRAOIDLigne;
       bool             m_bDeviseConstante;
       MODE_PAIEMENT    m_eNaturePiece;
       int              m_nIDEcriture;
       CLignesEcriture *m_pLignesEcr;
       CLignesEcriture *m_pEcartsChange;

       void __fastcall Init( const TDateTime &dateImputation, const AnsiString &strCodeJnl, TCodeDev eCodeDevise, double dTaux, int nRAOIDLigne, MODE_PAIEMENT eNaturePiece, bool bDeviseConst/*,const AnsiString &strIDEcriturePart*/);
       void __fastcall AjouterLigneHI( TTableHI *ptblHI, const AnsiString &strCompte,
                                     const AnsiString &strPiece,
                                     const AnsiString &strLettrage, TTableHI::HIFlagLettrage eFlagLettrage,
                                     const AnsiString &strLibelleOp, const Currency &curMontantOrigine, TCodeDev eCodeDevise,
                                     double dTauxChange, bool bEstCrediteur, int nFlags,
                                     int nIDImage,
                                     const TDateTime &dtDateEcheance,
                                     MODE_PAIEMENT eModePaiement,
                                     const TDateTime &dtRappr, int nCodeReviseur, int nRef);
       void __fastcall AjouterLigneHI2(CTable *ptblHI2, const TDateTime &dateRANOrigine,
                                     const AnsiString &strRANJnlOrigine,
                                     const AnsiString &strIDEcriturePart,
                                     const AnsiString &strRAOData, const AnsiString &strDesignation,
                                     double dQuantite, const AnsiString &strBanquePaiement,
                                     double dTauxTVA, const AnsiString &strCodeTVA,
                                     const AnsiString &strNaturePiece, const AnsiString &strPieceExt, const AnsiString &strCodeAnalytik,
                                     const TDateTime &dateDebPeriode, const TDateTime &dateFinPeriode);
       bool __fastcall GetEstEcritureImportee() const;
       bool __fastcall GetEstEcritureImporteeModifiee() const;

     public:
       __fastcall  CEcriture( const TDateTime &dateImputation, const AnsiString &strCodeJnl, MODE_PAIEMENT eNaturePiece = MP_AUCUN, int nRAOIDLigne = -1);
       __fastcall  CEcriture( TCodeDev eCodeDevise, double dTaux, const TDateTime &dateImputation, const AnsiString &strCodeJnl, MODE_PAIEMENT eNaturePiece = MP_AUCUN, int nRAOIDLigne = -1);
       __fastcall  CEcriture( CTable *ptbl,CTable *ptbl2, int nIdEcr);
       virtual __fastcall ~CEcriture();

       void __fastcall ForceEcritureNouvelle();
       void __fastcall TransformerEcritureImporteeEnNormale();
       void __fastcall ValideEcriture( TTableHI *ptblHI, TTablePC *ptblPC,CTable *ptblHI2, bool bMove, CBarre *pBarre /*= NULL*/);

       __property TCodeDev         CodeDevise      = { read=m_codeDevise     };
       __property AnsiString       CodeJournal     = { read=m_strCodeJournal };
       __property TDateTime        DateImputation  = { read=m_dateImputation };
       __property int              IDEcriture      = { read=m_nIDEcriture    };
       __property MODE_PAIEMENT    NaturePiece     = { read=m_eNaturePiece   };
       __property int              RAOIDLigne      = { read=m_nRAOIDLigne    };
       __property double           Taux            = { read=m_dTaux          };
       __property CLignesEcriture *LignesEcriture  = { read=m_pLignesEcr     };
       __property CLignesEcriture *EcartsChange    = { read=m_pEcartsChange  };

       __property bool EstEcritureImportee         = { read=GetEstEcritureImportee         };
       __property bool EstEcritureImporteeModifiee = { read=GetEstEcritureImporteeModifiee };
   };


   // (1) : les valeur par def sont initialisées directement dans la table
  } /* namespace Compta */
  #ifndef NO_IMPLICIT_NAMESPACE_USE
   using namespace Compta;
  #endif

 #endif /* #ifndef __BCPLUSPLUS__ #else */

//#endif /* #ifndef _AUTONOME */
 #endif /* #ifndef _COMPTA_H */
